Update GiST for new pg_opclass arrangement (finally a clean solution
for haskeytype). Update GiST contrib modules too. Add linear-time split algorithm for R-tree GiST opclass. From Oleg Bartunov and Teodor Sigaev.
This commit is contained in:
parent
38a4c35116
commit
a54075a6d6
@ -86,7 +86,7 @@ CREATE FUNCTION g_int_decompress(opaque) RETURNS opaque
|
||||
AS 'MODULE_PATHNAME' LANGUAGE 'c';
|
||||
|
||||
CREATE FUNCTION g_int_penalty(opaque,opaque,opaque) RETURNS opaque
|
||||
AS 'MODULE_PATHNAME' LANGUAGE 'c';
|
||||
AS 'MODULE_PATHNAME' LANGUAGE 'c' with (isstrict);
|
||||
|
||||
CREATE FUNCTION g_int_picksplit(opaque, opaque) RETURNS opaque
|
||||
AS 'MODULE_PATHNAME' LANGUAGE 'c';
|
||||
@ -105,7 +105,7 @@ INSERT INTO pg_opclass (opcamid, opcname, opcintype, opcdefault, opckeytype)
|
||||
'gist__int_ops',
|
||||
(SELECT oid FROM pg_type WHERE typname = '_int4'),
|
||||
true,
|
||||
(SELECT oid FROM pg_type WHERE typname = '_int4'));
|
||||
0);
|
||||
|
||||
|
||||
-- get the comparators for _intments and store them in a tmp table
|
||||
@ -252,7 +252,7 @@ INSERT INTO pg_opclass (opcamid, opcname, opcintype, opcdefault, opckeytype)
|
||||
'gist__intbig_ops',
|
||||
(SELECT oid FROM pg_type WHERE typname = '_int4'),
|
||||
false,
|
||||
(SELECT oid FROM pg_type WHERE typname = '_int4'));
|
||||
0);
|
||||
|
||||
|
||||
-- get the comparators for _intments and store them in a tmp table
|
||||
|
@ -19,7 +19,7 @@ select count(*) from boxtmp where b && '(1000,1000,0,0)'::box;
|
||||
(1 row)
|
||||
|
||||
drop index bix;
|
||||
create index bix on boxtmp using gist (b gist_box_ops);
|
||||
create index bix on boxtmp using gist (b);
|
||||
select count(*) from boxtmp where b && '(1000,1000,0,0)'::box;
|
||||
count
|
||||
-------
|
||||
@ -36,7 +36,7 @@ select count(*) from polytmp where p && '(1000,1000),(0,0)'::polygon;
|
||||
(1 row)
|
||||
|
||||
drop index pix;
|
||||
create index pix on polytmp using gist (p gist_poly_ops);
|
||||
create index pix on polytmp using gist (p);
|
||||
select count(*) from polytmp where p && '(1000,1000),(0,0)'::polygon;
|
||||
count
|
||||
-------
|
||||
|
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.1 2001/05/31 18:27:18 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/contrib/rtree_gist/Attic/rtree_gist.c,v 1.2 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -24,14 +24,6 @@ typedef Datum (*RDF)(PG_FUNCTION_ARGS);
|
||||
typedef Datum (*BINARY_UNION)(Datum, Datum, int*);
|
||||
typedef float (*SIZE_BOX)(Datum);
|
||||
|
||||
/*
|
||||
** Workaround for index_formtuple
|
||||
*/
|
||||
typedef struct polykey {
|
||||
int32 size; /* size in varlena terms */
|
||||
BOX key;
|
||||
} POLYKEY;
|
||||
|
||||
/*
|
||||
** box ops
|
||||
*/
|
||||
@ -42,14 +34,13 @@ PG_FUNCTION_INFO_V1(gbox_consistent);
|
||||
PG_FUNCTION_INFO_V1(gbox_penalty);
|
||||
PG_FUNCTION_INFO_V1(gbox_same);
|
||||
|
||||
GISTENTRY * gbox_compress(PG_FUNCTION_ARGS);
|
||||
BOX *gbox_union(PG_FUNCTION_ARGS);
|
||||
GIST_SPLITVEC * gbox_picksplit(PG_FUNCTION_ARGS);
|
||||
bool gbox_consistent(PG_FUNCTION_ARGS);
|
||||
float * gbox_penalty(PG_FUNCTION_ARGS);
|
||||
bool * gbox_same(PG_FUNCTION_ARGS);
|
||||
Datum gbox_compress(PG_FUNCTION_ARGS);
|
||||
Datum gbox_union(PG_FUNCTION_ARGS);
|
||||
Datum gbox_picksplit(PG_FUNCTION_ARGS);
|
||||
Datum gbox_consistent(PG_FUNCTION_ARGS);
|
||||
Datum gbox_penalty(PG_FUNCTION_ARGS);
|
||||
Datum gbox_same(PG_FUNCTION_ARGS);
|
||||
|
||||
static Datum gbox_binary_union(Datum r1, Datum r2, int *sizep);
|
||||
static bool gbox_leaf_consistent(BOX *key, BOX *query, StrategyNumber strategy);
|
||||
static float size_box( Datum box );
|
||||
|
||||
@ -57,37 +48,19 @@ static float size_box( Datum box );
|
||||
** Polygon ops
|
||||
*/
|
||||
PG_FUNCTION_INFO_V1(gpoly_compress);
|
||||
PG_FUNCTION_INFO_V1(gpoly_union);
|
||||
PG_FUNCTION_INFO_V1(gpoly_picksplit);
|
||||
PG_FUNCTION_INFO_V1(gpoly_consistent);
|
||||
PG_FUNCTION_INFO_V1(gpoly_penalty);
|
||||
PG_FUNCTION_INFO_V1(gpoly_same);
|
||||
|
||||
GISTENTRY * gpoly_compress(PG_FUNCTION_ARGS);
|
||||
POLYKEY *gpoly_union(PG_FUNCTION_ARGS);
|
||||
GIST_SPLITVEC * gpoly_picksplit(PG_FUNCTION_ARGS);
|
||||
bool gpoly_consistent(PG_FUNCTION_ARGS);
|
||||
float * gpoly_penalty(PG_FUNCTION_ARGS);
|
||||
bool * gpoly_same(PG_FUNCTION_ARGS);
|
||||
|
||||
static Datum gpoly_binary_union(Datum r1, Datum r2, int *sizep);
|
||||
static float size_polykey( Datum pk );
|
||||
|
||||
PG_FUNCTION_INFO_V1(gpoly_inter);
|
||||
Datum gpoly_inter(PG_FUNCTION_ARGS);
|
||||
Datum gpoly_compress(PG_FUNCTION_ARGS);
|
||||
Datum gpoly_consistent(PG_FUNCTION_ARGS);
|
||||
|
||||
/*
|
||||
** Common rtree-function (for all ops)
|
||||
*/
|
||||
static Datum rtree_union(bytea *entryvec, int *sizep, BINARY_UNION bu);
|
||||
static float * rtree_penalty(GISTENTRY *origentry, GISTENTRY *newentry,
|
||||
float *result, BINARY_UNION bu, SIZE_BOX sb);
|
||||
static GIST_SPLITVEC * rtree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
|
||||
int keylen, BINARY_UNION bu, RDF interop, SIZE_BOX sb);
|
||||
static bool rtree_internal_consistent(BOX *key, BOX *query, StrategyNumber strategy);
|
||||
|
||||
PG_FUNCTION_INFO_V1(rtree_decompress);
|
||||
GISTENTRY * rtree_decompress(PG_FUNCTION_ARGS);
|
||||
|
||||
Datum rtree_decompress(PG_FUNCTION_ARGS);
|
||||
|
||||
/**************************************************
|
||||
* Box ops
|
||||
@ -99,18 +72,19 @@ GISTENTRY * rtree_decompress(PG_FUNCTION_ARGS);
|
||||
** the predicate x op query == FALSE, where op is the oper
|
||||
** corresponding to strategy in the pg_amop table.
|
||||
*/
|
||||
bool
|
||||
Datum
|
||||
gbox_consistent(PG_FUNCTION_ARGS)
|
||||
{
|
||||
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
|
||||
BOX *query = (BOX*) PG_GETARG_POINTER(1);
|
||||
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
|
||||
|
||||
/*
|
||||
** if entry is not leaf, use gbox_internal_consistent,
|
||||
** else use gbox_leaf_consistent
|
||||
*/
|
||||
if ( ! (DatumGetPointer(entry->key) != NULL && query) )
|
||||
return FALSE;
|
||||
PG_RETURN_BOOL(FALSE);
|
||||
|
||||
if (GIST_LEAF(entry))
|
||||
PG_RETURN_BOOL(gbox_leaf_consistent((BOX *) DatumGetPointer(entry->key), query, strategy));
|
||||
@ -123,66 +97,221 @@ gbox_consistent(PG_FUNCTION_ARGS)
|
||||
** The GiST Union method for boxes
|
||||
** returns the minimal bounding box that encloses all the entries in entryvec
|
||||
*/
|
||||
BOX *
|
||||
Datum
|
||||
gbox_union(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return (BOX*)
|
||||
DatumGetPointer(rtree_union(
|
||||
(bytea*) PG_GETARG_POINTER(0),
|
||||
(int*) PG_GETARG_POINTER(1),
|
||||
gbox_binary_union
|
||||
));
|
||||
bytea *entryvec = (bytea*) PG_GETARG_POINTER(0);
|
||||
int *sizep = (int*) PG_GETARG_POINTER(1);
|
||||
int numranges, i;
|
||||
BOX *cur, *pageunion;
|
||||
|
||||
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
|
||||
pageunion = (BOX *)palloc( sizeof(BOX) );
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[0].key );
|
||||
memcpy( (void*)pageunion, (void*)cur, sizeof( BOX ) );
|
||||
|
||||
for (i = 1; i < numranges; i++) {
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
|
||||
if ( pageunion->high.x < cur->high.x )
|
||||
pageunion->high.x = cur->high.x;
|
||||
if ( pageunion->low.x > cur->low.x )
|
||||
pageunion->low.x = cur->low.x;
|
||||
if ( pageunion->high.y < cur->high.y )
|
||||
pageunion->high.y = cur->high.y;
|
||||
if ( pageunion->low.y > cur->low.y )
|
||||
pageunion->low.y = cur->low.y;
|
||||
}
|
||||
*sizep = sizeof(BOX);
|
||||
|
||||
PG_RETURN_POINTER(pageunion);
|
||||
}
|
||||
|
||||
/*
|
||||
** GiST Compress methods for boxes
|
||||
** do not do anything.
|
||||
*/
|
||||
GISTENTRY *
|
||||
Datum
|
||||
gbox_compress(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return((GISTENTRY*)PG_GETARG_POINTER(0));
|
||||
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
|
||||
}
|
||||
|
||||
/*
|
||||
** The GiST Penalty method for boxes
|
||||
** As in the R-tree paper, we use change in area as our penalty metric
|
||||
*/
|
||||
float *
|
||||
Datum
|
||||
gbox_penalty(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return rtree_penalty(
|
||||
(GISTENTRY*) PG_GETARG_POINTER(0),
|
||||
(GISTENTRY*) PG_GETARG_POINTER(1),
|
||||
(float*) PG_GETARG_POINTER(2),
|
||||
gbox_binary_union,
|
||||
size_box
|
||||
);
|
||||
GISTENTRY *origentry = (GISTENTRY*) PG_GETARG_POINTER(0);
|
||||
GISTENTRY *newentry = (GISTENTRY*) PG_GETARG_POINTER(1);
|
||||
float *result = (float*) PG_GETARG_POINTER(2);
|
||||
Datum ud;
|
||||
float tmp1;
|
||||
|
||||
ud = DirectFunctionCall2(rt_box_union, origentry->key, newentry->key);
|
||||
tmp1 = size_box( ud );
|
||||
if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud));
|
||||
|
||||
*result = tmp1 - size_box( origentry->key );
|
||||
PG_RETURN_POINTER(result);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** The GiST PickSplit method for boxes
|
||||
** We use Guttman's poly time split algorithm
|
||||
** The GiST PickSplit method
|
||||
** New linear algorithm, see 'New Linear Node Splitting Algorithm for R-tree',
|
||||
** C.H.Ang and T.C.Tan
|
||||
*/
|
||||
GIST_SPLITVEC *
|
||||
Datum
|
||||
gbox_picksplit(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return rtree_picksplit(
|
||||
(bytea*)PG_GETARG_POINTER(0),
|
||||
(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
|
||||
sizeof(BOX),
|
||||
gbox_binary_union,
|
||||
rt_box_inter,
|
||||
size_box
|
||||
);
|
||||
bytea *entryvec = (bytea*)PG_GETARG_POINTER(0);
|
||||
GIST_SPLITVEC *v = (GIST_SPLITVEC*)PG_GETARG_POINTER(1);
|
||||
OffsetNumber i;
|
||||
OffsetNumber *listL, *listR, *listB, *listT;
|
||||
BOX *unionL,*unionR,*unionB,*unionT;
|
||||
int posL, posR, posB, posT;
|
||||
BOX pageunion;
|
||||
BOX *cur;
|
||||
char direction=' ';
|
||||
bool allisequal=true;
|
||||
OffsetNumber maxoff;
|
||||
int nbytes;
|
||||
|
||||
posL = posR = posB = posT = 0;
|
||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 1;
|
||||
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key );
|
||||
memcpy( (void*)&pageunion, (void*)cur, sizeof( BOX ) );
|
||||
|
||||
/* find MBR */
|
||||
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i)) {
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
|
||||
if ( pageunion.high.x < cur->high.x )
|
||||
{ allisequal=false; pageunion.high.x = cur->high.x; }
|
||||
if ( pageunion.low.x > cur->low.x )
|
||||
{ allisequal=false; pageunion.low.x = cur->low.x; }
|
||||
if ( pageunion.high.y < cur->high.y )
|
||||
{ allisequal=false; pageunion.high.y = cur->high.y; }
|
||||
if ( pageunion.low.y > cur->low.y )
|
||||
{ allisequal=false; pageunion.low.y = cur->low.y; }
|
||||
}
|
||||
|
||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||
listL = (OffsetNumber*)palloc( nbytes );
|
||||
listR = (OffsetNumber*)palloc( nbytes );
|
||||
unionL = (BOX*)palloc( sizeof(BOX) );
|
||||
unionR = (BOX*)palloc( sizeof(BOX) );
|
||||
if ( allisequal ) {
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key );
|
||||
if ( memcmp( (void*)cur, (void*)&pageunion, sizeof( BOX ) ) == 0 ) {
|
||||
v->spl_left = listL;
|
||||
v->spl_right = listR;
|
||||
v->spl_nleft = v->spl_nright = 0;
|
||||
memcpy( (void*)unionL, (void*)&pageunion, sizeof( BOX ) );
|
||||
memcpy( (void*)unionR, (void*)&pageunion, sizeof( BOX ) );
|
||||
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
|
||||
if (i <= (maxoff - FirstOffsetNumber + 1)/2) {
|
||||
v->spl_left[ v->spl_nleft ] = i;
|
||||
v->spl_nleft++;
|
||||
} else {
|
||||
v->spl_right[ v->spl_nright ] = i;
|
||||
v->spl_nright++;
|
||||
}
|
||||
}
|
||||
v->spl_ldatum = BoxPGetDatum( unionL );
|
||||
v->spl_rdatum = BoxPGetDatum( unionR );
|
||||
|
||||
PG_RETURN_POINTER( v );
|
||||
}
|
||||
}
|
||||
|
||||
listB = (OffsetNumber*)palloc( nbytes );
|
||||
listT = (OffsetNumber*)palloc( nbytes );
|
||||
unionB = (BOX*)palloc( sizeof(BOX) );
|
||||
unionT = (BOX*)palloc( sizeof(BOX) );
|
||||
|
||||
#define ADDLIST( list, unionD, pos ) do { \
|
||||
if ( pos ) { \
|
||||
if ( unionD->high.x < cur->high.x ) unionD->high.x = cur->high.x; \
|
||||
if ( unionD->low.x > cur->low.x ) unionD->low.x = cur->low.x; \
|
||||
if ( unionD->high.y < cur->high.y ) unionD->high.y = cur->high.y; \
|
||||
if ( unionD->low.y > cur->low.y ) unionD->low.y = cur->low.y; \
|
||||
} else { \
|
||||
memcpy( (void*)unionD, (void*) cur, sizeof( BOX ) ); \
|
||||
} \
|
||||
list[pos] = i; \
|
||||
(pos)++; \
|
||||
} while(0)
|
||||
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
|
||||
cur = DatumGetBoxP( ((GISTENTRY *) VARDATA(entryvec))[i].key );
|
||||
if ( cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x )
|
||||
ADDLIST( listL, unionL, posL );
|
||||
else
|
||||
ADDLIST( listR, unionR, posR );
|
||||
if ( cur->low.y - pageunion.low.y < pageunion.high.y - cur->high.y )
|
||||
ADDLIST( listB, unionB, posB );
|
||||
else
|
||||
ADDLIST( listT, unionT, posT );
|
||||
}
|
||||
|
||||
/* which split more optimal? */
|
||||
|
||||
if ( Max( posL, posR ) < Max( posB, posT ) ) {
|
||||
direction = 'x';
|
||||
} else if ( Max( posL, posR ) > Max( posB, posT ) ) {
|
||||
direction = 'y';
|
||||
} else {
|
||||
Datum interLR = DirectFunctionCall2(rt_box_inter,
|
||||
BoxPGetDatum(unionL),
|
||||
BoxPGetDatum(unionR));
|
||||
Datum interBT = DirectFunctionCall2(rt_box_inter,
|
||||
BoxPGetDatum(unionB),
|
||||
BoxPGetDatum(unionT));
|
||||
float sizeLR, sizeBT;
|
||||
|
||||
sizeLR = size_box( interLR );
|
||||
sizeBT = size_box( interBT );
|
||||
|
||||
if ( sizeLR < sizeBT ) {
|
||||
direction = 'x';
|
||||
//} else if ( sizeLR > sizeBT ) {
|
||||
} else {
|
||||
direction = 'y';
|
||||
}
|
||||
}
|
||||
|
||||
if ( direction == 'x' ) {
|
||||
pfree( unionB ); pfree( listB );
|
||||
pfree( unionT ); pfree( listT );
|
||||
|
||||
v->spl_left = listL;
|
||||
v->spl_right = listR;
|
||||
v->spl_nleft = posL;
|
||||
v->spl_nright = posR;
|
||||
v->spl_ldatum = BoxPGetDatum( unionL );
|
||||
v->spl_rdatum = BoxPGetDatum( unionR );
|
||||
} else {
|
||||
pfree( unionR ); pfree( listR );
|
||||
pfree( unionL ); pfree( listL );
|
||||
|
||||
v->spl_left = listB;
|
||||
v->spl_right = listT;
|
||||
v->spl_nleft = posB;
|
||||
v->spl_nright = posT;
|
||||
v->spl_ldatum = BoxPGetDatum( unionB );
|
||||
v->spl_rdatum = BoxPGetDatum( unionT );
|
||||
}
|
||||
|
||||
PG_RETURN_POINTER (v);
|
||||
}
|
||||
|
||||
/*
|
||||
** Equality method
|
||||
*/
|
||||
bool *
|
||||
Datum
|
||||
gbox_same(PG_FUNCTION_ARGS)
|
||||
{
|
||||
BOX *b1 = (BOX*) PG_GETARG_POINTER(0);
|
||||
@ -192,7 +321,7 @@ gbox_same(PG_FUNCTION_ARGS)
|
||||
*result = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(b1), PointerGetDatum(b2)) );
|
||||
else
|
||||
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
|
||||
return(result);
|
||||
PG_RETURN_POINTER(result);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -236,32 +365,6 @@ gbox_leaf_consistent(BOX *key,
|
||||
return(retval);
|
||||
}
|
||||
|
||||
static Datum
|
||||
gbox_binary_union(Datum r1, Datum r2, int *sizep)
|
||||
{
|
||||
BOX *retval;
|
||||
|
||||
if ( ! (DatumGetPointer(r1) != NULL && DatumGetPointer(r2) != NULL) ) {
|
||||
if ( DatumGetPointer(r1) != NULL ) {
|
||||
retval = (BOX*) palloc( sizeof(BOX) );
|
||||
memcpy( retval, DatumGetPointer(r1), sizeof(BOX) );
|
||||
*sizep = sizeof(BOX);
|
||||
} else if ( DatumGetPointer(r2) != NULL ) {
|
||||
retval = (BOX*) palloc( sizeof(BOX) );
|
||||
memcpy( retval, DatumGetPointer(r2), sizeof(BOX) );
|
||||
*sizep = sizeof(BOX);
|
||||
} else {
|
||||
*sizep = 0;
|
||||
retval = NULL;
|
||||
}
|
||||
} else {
|
||||
retval = (BOX*) DatumGetPointer(
|
||||
DirectFunctionCall2(rt_box_union, r1, r2));
|
||||
*sizep = sizeof(BOX);
|
||||
}
|
||||
return PointerGetDatum(retval);
|
||||
}
|
||||
|
||||
static float
|
||||
size_box( Datum box ) {
|
||||
if ( DatumGetPointer(box) != NULL ) {
|
||||
@ -278,7 +381,7 @@ size_box( Datum box ) {
|
||||
* Polygon ops
|
||||
**************************************************/
|
||||
|
||||
GISTENTRY *
|
||||
Datum
|
||||
gpoly_compress(PG_FUNCTION_ARGS)
|
||||
{
|
||||
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
|
||||
@ -288,17 +391,16 @@ gpoly_compress(PG_FUNCTION_ARGS)
|
||||
retval = palloc(sizeof(GISTENTRY));
|
||||
if ( DatumGetPointer(entry->key) != NULL ) {
|
||||
POLYGON *in;
|
||||
POLYKEY *r;
|
||||
BOX *r;
|
||||
in = (POLYGON *) PG_DETOAST_DATUM(entry->key);
|
||||
r = (POLYKEY *) palloc( sizeof(POLYKEY) );
|
||||
r->size = sizeof(POLYKEY);
|
||||
memcpy( (void*)&(r->key), (void*)&(in->boundbox), sizeof(BOX) );
|
||||
r = (BOX *) palloc( sizeof(BOX) );
|
||||
memcpy( (void*)r, (void*)&(in->boundbox), sizeof(BOX) );
|
||||
if ( in != (POLYGON *) DatumGetPointer(entry->key) )
|
||||
pfree( in );
|
||||
|
||||
gistentryinit(*retval, PointerGetDatum(r),
|
||||
entry->rel, entry->page,
|
||||
entry->offset, sizeof(POLYKEY), FALSE);
|
||||
entry->offset, sizeof(BOX), FALSE);
|
||||
|
||||
} else {
|
||||
gistentryinit(*retval, (Datum) 0,
|
||||
@ -308,355 +410,34 @@ gpoly_compress(PG_FUNCTION_ARGS)
|
||||
} else {
|
||||
retval = entry;
|
||||
}
|
||||
return( retval );
|
||||
PG_RETURN_POINTER( retval );
|
||||
}
|
||||
|
||||
bool
|
||||
Datum
|
||||
gpoly_consistent(PG_FUNCTION_ARGS)
|
||||
{
|
||||
GISTENTRY *entry = (GISTENTRY*) PG_GETARG_POINTER(0);
|
||||
POLYGON *query = (POLYGON*)PG_DETOAST_DATUM( PG_GETARG_POINTER(1) );
|
||||
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
|
||||
bool result;
|
||||
|
||||
/*
|
||||
** if entry is not leaf, use gbox_internal_consistent,
|
||||
** else use gbox_leaf_consistent
|
||||
*/
|
||||
if ( ! (DatumGetPointer(entry->key) != NULL && query) )
|
||||
return FALSE;
|
||||
PG_RETURN_BOOL(FALSE);
|
||||
|
||||
result = rtree_internal_consistent((BOX*)&( ((POLYKEY *) DatumGetPointer(entry->key))->key ),
|
||||
result = rtree_internal_consistent((BOX *) DatumGetPointer(entry->key),
|
||||
&(query->boundbox), strategy);
|
||||
|
||||
PG_FREE_IF_COPY(query,1);
|
||||
PG_RETURN_BOOL( result );
|
||||
}
|
||||
|
||||
POLYKEY *
|
||||
gpoly_union(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return (POLYKEY*)
|
||||
DatumGetPointer(rtree_union(
|
||||
(bytea*) PG_GETARG_POINTER(0),
|
||||
(int*) PG_GETARG_POINTER(1),
|
||||
gpoly_binary_union
|
||||
));
|
||||
}
|
||||
|
||||
float *
|
||||
gpoly_penalty(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return rtree_penalty(
|
||||
(GISTENTRY*) PG_GETARG_POINTER(0),
|
||||
(GISTENTRY*) PG_GETARG_POINTER(1),
|
||||
(float*) PG_GETARG_POINTER(2),
|
||||
gpoly_binary_union,
|
||||
size_polykey
|
||||
);
|
||||
}
|
||||
|
||||
GIST_SPLITVEC *
|
||||
gpoly_picksplit(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return rtree_picksplit(
|
||||
(bytea*)PG_GETARG_POINTER(0),
|
||||
(GIST_SPLITVEC*)PG_GETARG_POINTER(1),
|
||||
sizeof(POLYKEY),
|
||||
gpoly_binary_union,
|
||||
gpoly_inter,
|
||||
size_polykey
|
||||
);
|
||||
}
|
||||
|
||||
bool *
|
||||
gpoly_same(PG_FUNCTION_ARGS)
|
||||
{
|
||||
POLYKEY *b1 = (POLYKEY*) PG_GETARG_POINTER(0);
|
||||
POLYKEY *b2 = (POLYKEY*) PG_GETARG_POINTER(1);
|
||||
|
||||
bool *result = (bool*) PG_GETARG_POINTER(2);
|
||||
if ( b1 && b2 )
|
||||
*result = DatumGetBool( DirectFunctionCall2( box_same,
|
||||
PointerGetDatum(&(b1->key)),
|
||||
PointerGetDatum(&(b2->key))) );
|
||||
else
|
||||
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
|
||||
return(result);
|
||||
}
|
||||
|
||||
/*
|
||||
** SUPPORT ROUTINES for polygons
|
||||
*/
|
||||
Datum
|
||||
gpoly_inter(PG_FUNCTION_ARGS)
|
||||
{
|
||||
POLYKEY *b1 = (POLYKEY*) PG_GETARG_POINTER(0);
|
||||
POLYKEY *b2 = (POLYKEY*) PG_GETARG_POINTER(1);
|
||||
Datum interd;
|
||||
|
||||
interd = DirectFunctionCall2(rt_box_inter,
|
||||
PointerGetDatum( &(b1->key) ),
|
||||
PointerGetDatum( &(b2->key) ));
|
||||
|
||||
if (DatumGetPointer(interd) != NULL) {
|
||||
POLYKEY *tmp = (POLYKEY*) palloc( sizeof(POLYKEY) );
|
||||
tmp->size = sizeof(POLYKEY);
|
||||
memcpy( &(tmp->key), DatumGetPointer(interd), sizeof(BOX) );
|
||||
pfree( DatumGetPointer(interd) );
|
||||
PG_RETURN_POINTER( tmp );
|
||||
} else
|
||||
PG_RETURN_POINTER( NULL );
|
||||
}
|
||||
|
||||
static Datum
|
||||
gpoly_binary_union(Datum r1, Datum r2, int *sizep)
|
||||
{
|
||||
POLYKEY *retval;
|
||||
|
||||
if ( ! (DatumGetPointer(r1) != NULL && DatumGetPointer(r2) != NULL) ) {
|
||||
if ( DatumGetPointer(r1) != NULL ) {
|
||||
retval = (POLYKEY*)palloc( sizeof(POLYKEY) );
|
||||
memcpy( (void*)retval, DatumGetPointer(r1), sizeof(POLYKEY) );
|
||||
*sizep = sizeof(POLYKEY);
|
||||
} else if ( DatumGetPointer(r2) != NULL ) {
|
||||
retval = (POLYKEY*)palloc( sizeof(POLYKEY) );
|
||||
memcpy( (void*)retval, DatumGetPointer(r2), sizeof(POLYKEY) );
|
||||
*sizep = sizeof(POLYKEY);
|
||||
} else {
|
||||
*sizep = 0;
|
||||
retval = NULL;
|
||||
}
|
||||
} else {
|
||||
BOX *key = (BOX*)DatumGetPointer(
|
||||
DirectFunctionCall2(
|
||||
rt_box_union,
|
||||
PointerGetDatum( &(((POLYKEY*) DatumGetPointer(r1))->key) ),
|
||||
PointerGetDatum( &(((POLYKEY*) DatumGetPointer(r2))->key) )) );
|
||||
retval = (POLYKEY*)palloc( sizeof(POLYKEY) );
|
||||
memcpy( &(retval->key), key, sizeof(BOX) );
|
||||
pfree( key );
|
||||
*sizep = retval->size = sizeof(POLYKEY);
|
||||
}
|
||||
return PointerGetDatum(retval);
|
||||
}
|
||||
|
||||
|
||||
static float
|
||||
size_polykey( Datum pk ) {
|
||||
if ( DatumGetPointer(pk) != NULL ) {
|
||||
float size;
|
||||
|
||||
DirectFunctionCall2( rt_box_size,
|
||||
PointerGetDatum( &(((POLYKEY*) DatumGetPointer(pk))->key) ),
|
||||
PointerGetDatum( &size ) );
|
||||
return size;
|
||||
} else
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Common rtree-function (for all ops)
|
||||
*/
|
||||
|
||||
static Datum
|
||||
rtree_union(bytea *entryvec, int *sizep, BINARY_UNION bu)
|
||||
{
|
||||
int numranges, i;
|
||||
Datum out,
|
||||
tmp;
|
||||
|
||||
numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
|
||||
tmp = ((GISTENTRY *) VARDATA(entryvec))[0].key;
|
||||
out = (Datum) 0;
|
||||
|
||||
for (i = 1; i < numranges; i++) {
|
||||
out = (*bu)(tmp,
|
||||
((GISTENTRY *) VARDATA(entryvec))[i].key,
|
||||
sizep);
|
||||
if (i > 1 && DatumGetPointer(tmp) != NULL)
|
||||
pfree(DatumGetPointer(tmp));
|
||||
tmp = out;
|
||||
}
|
||||
|
||||
return(out);
|
||||
}
|
||||
|
||||
static float *
|
||||
rtree_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result, BINARY_UNION bu, SIZE_BOX sb)
|
||||
{
|
||||
Datum ud;
|
||||
float tmp1;
|
||||
int sizep;
|
||||
|
||||
ud = (*bu)( origentry->key, newentry->key, &sizep );
|
||||
tmp1 = (*sb)( ud );
|
||||
if (DatumGetPointer(ud) != NULL) pfree(DatumGetPointer(ud));
|
||||
|
||||
*result = tmp1 - (*sb)( origentry->key );
|
||||
return(result);
|
||||
}
|
||||
|
||||
/*
|
||||
** The GiST PickSplit method
|
||||
** We use Guttman's poly time split algorithm
|
||||
*/
|
||||
static GIST_SPLITVEC *
|
||||
rtree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, int keylen, BINARY_UNION bu, RDF interop, SIZE_BOX sb)
|
||||
{
|
||||
OffsetNumber i, j;
|
||||
Datum datum_alpha, datum_beta;
|
||||
Datum datum_l, datum_r;
|
||||
Datum union_d, union_dl, union_dr;
|
||||
Datum inter_d;
|
||||
bool firsttime;
|
||||
float size_alpha, size_beta, size_union, size_inter;
|
||||
float size_waste, waste;
|
||||
float size_l, size_r;
|
||||
int nbytes;
|
||||
int sizep;
|
||||
OffsetNumber seed_1 = 0, seed_2 = 0;
|
||||
OffsetNumber *left, *right;
|
||||
OffsetNumber maxoff;
|
||||
|
||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY)) - 2;
|
||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||
|
||||
firsttime = true;
|
||||
waste = 0.0;
|
||||
|
||||
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i)) {
|
||||
datum_alpha = ((GISTENTRY *) VARDATA(entryvec))[i].key;
|
||||
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) {
|
||||
datum_beta = ((GISTENTRY *) VARDATA(entryvec))[j].key;
|
||||
|
||||
/* compute the wasted space by unioning these guys */
|
||||
/* size_waste = size_union - size_inter; */
|
||||
union_d = (*bu)( datum_alpha, datum_beta, &sizep );
|
||||
if ( DatumGetPointer(union_d) != NULL ) {
|
||||
size_union = (*sb)(union_d);
|
||||
pfree(DatumGetPointer(union_d));
|
||||
} else
|
||||
size_union = 0.0;
|
||||
|
||||
if ( DatumGetPointer(datum_alpha) != NULL &&
|
||||
DatumGetPointer(datum_beta) != NULL ) {
|
||||
inter_d = DirectFunctionCall2(interop,
|
||||
datum_alpha,
|
||||
datum_beta);
|
||||
if ( DatumGetPointer(inter_d) != NULL ) {
|
||||
size_inter = (*sb)(inter_d);
|
||||
pfree(DatumGetPointer(inter_d));
|
||||
} else
|
||||
size_inter = 0.0;
|
||||
} else
|
||||
size_inter = 0.0;
|
||||
|
||||
size_waste = size_union - size_inter;
|
||||
|
||||
/*
|
||||
* are these a more promising split that what we've
|
||||
* already seen?
|
||||
*/
|
||||
|
||||
if (size_waste > waste || firsttime) {
|
||||
waste = size_waste;
|
||||
seed_1 = i;
|
||||
seed_2 = j;
|
||||
firsttime = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
left = v->spl_left;
|
||||
v->spl_nleft = 0;
|
||||
right = v->spl_right;
|
||||
v->spl_nright = 0;
|
||||
|
||||
if ( DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_1].key) != NULL )
|
||||
{
|
||||
datum_l = PointerGetDatum(palloc( keylen ));
|
||||
memcpy(DatumGetPointer(datum_l),
|
||||
DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_1].key),
|
||||
keylen);
|
||||
} else
|
||||
datum_l = (Datum) 0;
|
||||
size_l = (*sb)( datum_l );
|
||||
if ( DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_2].key) != NULL )
|
||||
{
|
||||
datum_r = PointerGetDatum(palloc( keylen ));
|
||||
memcpy(DatumGetPointer(datum_r),
|
||||
DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_2].key),
|
||||
keylen);
|
||||
} else
|
||||
datum_r = (Datum) 0;
|
||||
size_r = (*sb)( datum_r );
|
||||
|
||||
/*
|
||||
* Now split up the regions between the two seeds. An important
|
||||
* property of this split algorithm is that the split vector v
|
||||
* has the indices of items to be split in order in its left and
|
||||
* right vectors. We exploit this property by doing a merge in
|
||||
* the code that actually splits the page.
|
||||
*
|
||||
* For efficiency, we also place the new index tuple in this loop.
|
||||
* This is handled at the very end, when we have placed all the
|
||||
* existing tuples and i == maxoff + 1.
|
||||
*/
|
||||
|
||||
maxoff = OffsetNumberNext(maxoff);
|
||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) {
|
||||
|
||||
/*
|
||||
* If we've already decided where to place this item, just
|
||||
* put it on the right list. Otherwise, we need to figure
|
||||
* out which page needs the least enlargement in order to
|
||||
* store the item.
|
||||
*/
|
||||
|
||||
if (i == seed_1) {
|
||||
*left++ = i;
|
||||
v->spl_nleft++;
|
||||
continue;
|
||||
} else if (i == seed_2) {
|
||||
*right++ = i;
|
||||
v->spl_nright++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* okay, which page needs least enlargement? */
|
||||
datum_alpha = ((GISTENTRY *) VARDATA(entryvec))[i].key;
|
||||
union_dl = (*bu)( datum_l, datum_alpha, &sizep );
|
||||
union_dr = (*bu)( datum_r, datum_alpha, &sizep );
|
||||
size_alpha = (*sb)( union_dl );
|
||||
size_beta = (*sb)( union_dr );
|
||||
|
||||
/* pick which page to add it to */
|
||||
if (size_alpha - size_l < size_beta - size_r) {
|
||||
pfree(DatumGetPointer(datum_l));
|
||||
pfree(DatumGetPointer(union_dr));
|
||||
datum_l = union_dl;
|
||||
size_l = size_alpha;
|
||||
*left++ = i;
|
||||
v->spl_nleft++;
|
||||
} else {
|
||||
pfree(DatumGetPointer(datum_r));
|
||||
pfree(DatumGetPointer(union_dl));
|
||||
datum_r = union_dr;
|
||||
size_r = size_alpha;
|
||||
*right++ = i;
|
||||
v->spl_nright++;
|
||||
}
|
||||
}
|
||||
*left = *right = FirstOffsetNumber; /* sentinel value, see dosplit() */
|
||||
|
||||
v->spl_ldatum = datum_l;
|
||||
v->spl_rdatum = datum_r;
|
||||
|
||||
return( v );
|
||||
}
|
||||
/*****************************************
|
||||
* Common rtree-function (for all ops)
|
||||
*****************************************/
|
||||
|
||||
static bool
|
||||
rtree_internal_consistent(BOX *key,
|
||||
@ -694,8 +475,8 @@ rtree_internal_consistent(BOX *key,
|
||||
** GiST DeCompress methods
|
||||
** do not do anything.
|
||||
*/
|
||||
GISTENTRY *
|
||||
Datum
|
||||
rtree_decompress(PG_FUNCTION_ARGS)
|
||||
{
|
||||
return((GISTENTRY*)PG_GETARG_POINTER(0));
|
||||
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
|
||||
}
|
||||
|
@ -27,7 +27,7 @@ INSERT INTO pg_opclass (opcamid, opcname, opcintype, opcdefault, opckeytype)
|
||||
(SELECT oid FROM pg_am WHERE amname = 'gist'),
|
||||
'gist_box_ops',
|
||||
(SELECT oid FROM pg_type WHERE typname = 'box'),
|
||||
false,
|
||||
true,
|
||||
0);
|
||||
|
||||
-- get the comparators for boxes and store them in a tmp table
|
||||
@ -183,22 +183,14 @@ create function gpoly_consistent(opaque,polygon,int4) returns bool as 'MODULE_PA
|
||||
|
||||
create function gpoly_compress(opaque) returns opaque as 'MODULE_PATHNAME' language 'C';
|
||||
|
||||
create function gpoly_penalty(opaque,opaque,opaque) returns opaque as 'MODULE_PATHNAME' language 'C';
|
||||
|
||||
create function gpoly_picksplit(opaque, opaque) returns opaque as 'MODULE_PATHNAME' language 'C';
|
||||
|
||||
create function gpoly_union(bytea, opaque) returns opaque as 'MODULE_PATHNAME' language 'C';
|
||||
|
||||
create function gpoly_same(opaque, opaque, opaque) returns opaque as 'MODULE_PATHNAME' language 'C';
|
||||
|
||||
-- add a new opclass (non-default)
|
||||
INSERT INTO pg_opclass (opcamid, opcname, opcintype, opcdefault, opckeytype)
|
||||
VALUES (
|
||||
(SELECT oid FROM pg_am WHERE amname = 'gist'),
|
||||
'gist_poly_ops',
|
||||
(SELECT oid FROM pg_type WHERE typname = 'polygon'),
|
||||
false,
|
||||
0);
|
||||
true,
|
||||
(SELECT oid FROM pg_type WHERE typname = 'box'));
|
||||
|
||||
-- get the comparators for polygons and store them in a tmp table
|
||||
-- hack for 757 (poly_contain_pt) Teodor
|
||||
@ -211,7 +203,7 @@ WHERE o.oprleft = t.oid and o.oid <> 757
|
||||
-- using the tmp table, generate the amop entries
|
||||
-- poly_left
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 1, false, c.opoid
|
||||
SELECT opcl.oid, 1, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -220,7 +212,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_overleft
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 2, false, c.opoid
|
||||
SELECT opcl.oid, 2, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -229,7 +221,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_overlap
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 3, false, c.opoid
|
||||
SELECT opcl.oid, 3, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -238,7 +230,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_overright
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 4, false, c.opoid
|
||||
SELECT opcl.oid, 4, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -247,7 +239,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_right
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 5, false, c.opoid
|
||||
SELECT opcl.oid, 5, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -256,7 +248,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_same
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 6, false, c.opoid
|
||||
SELECT opcl.oid, 6, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -265,7 +257,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_contains
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 7, false, c.opoid
|
||||
SELECT opcl.oid, 7, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -274,7 +266,7 @@ INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
|
||||
-- poly_contained
|
||||
INSERT INTO pg_amop (amopclaid, amopstrategy, amopreqcheck, amopopr)
|
||||
SELECT opcl.oid, 8, false, c.opoid
|
||||
SELECT opcl.oid, 8, true, c.opoid
|
||||
FROM pg_opclass opcl, rt_ops_tmp c
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
@ -300,7 +292,7 @@ INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
and opcname = 'gist_poly_ops'
|
||||
and proname = 'gpoly_union';
|
||||
and proname = 'gbox_union';
|
||||
|
||||
INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
SELECT opcl.oid, 3, pro.oid
|
||||
@ -324,7 +316,7 @@ INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
and opcname = 'gist_poly_ops'
|
||||
and proname = 'gpoly_penalty';
|
||||
and proname = 'gbox_penalty';
|
||||
|
||||
INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
SELECT opcl.oid, 6, pro.oid
|
||||
@ -332,7 +324,7 @@ INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
and opcname = 'gist_poly_ops'
|
||||
and proname = 'gpoly_picksplit';
|
||||
and proname = 'gbox_picksplit';
|
||||
|
||||
INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
SELECT opcl.oid, 7, pro.oid
|
||||
@ -340,7 +332,7 @@ INSERT INTO pg_amproc (amopclaid, amprocnum, amproc)
|
||||
WHERE
|
||||
opcamid = (SELECT oid FROM pg_am WHERE amname = 'gist')
|
||||
and opcname = 'gist_poly_ops'
|
||||
and proname = 'gpoly_same';
|
||||
and proname = 'gbox_same';
|
||||
|
||||
end transaction;
|
||||
|
||||
|
@ -18,7 +18,7 @@ select count(*) from boxtmp where b && '(1000,1000,0,0)'::box;
|
||||
|
||||
drop index bix;
|
||||
|
||||
create index bix on boxtmp using gist (b gist_box_ops);
|
||||
create index bix on boxtmp using gist (b);
|
||||
|
||||
select count(*) from boxtmp where b && '(1000,1000,0,0)'::box;
|
||||
|
||||
@ -32,7 +32,7 @@ select count(*) from polytmp where p && '(1000,1000),(0,0)'::polygon;
|
||||
|
||||
drop index pix;
|
||||
|
||||
create index pix on polytmp using gist (p gist_poly_ops);
|
||||
create index pix on polytmp using gist (p);
|
||||
|
||||
select count(*) from polytmp where p && '(1000,1000),(0,0)'::polygon;
|
||||
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.82 2001/08/21 16:35:59 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.83 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -19,21 +19,15 @@
|
||||
#include "access/gistscan.h"
|
||||
#include "access/heapam.h"
|
||||
#include "catalog/index.h"
|
||||
#include "catalog/pg_index.h"
|
||||
#include "catalog/pg_opclass.h"
|
||||
#include "executor/executor.h"
|
||||
#include "miscadmin.h"
|
||||
#include "utils/lsyscache.h"
|
||||
#include "utils/syscache.h"
|
||||
#include "access/xlogutils.h"
|
||||
|
||||
|
||||
#undef GIST_PAGEADDITEM
|
||||
|
||||
#define ATTSIZE( datum, Rel, i, isnull ) \
|
||||
#define ATTSIZE( datum, TupDesc, i, isnull ) \
|
||||
( \
|
||||
( isnull ) ? 0 : \
|
||||
att_addlength(0, (Rel)->rd_att->attrs[(i)-1]->attlen, (datum)) \
|
||||
att_addlength(0, (TupDesc)->attrs[(i)-1]->attlen, (datum)) \
|
||||
)
|
||||
|
||||
/* result's status */
|
||||
@ -214,6 +208,7 @@ gistbuild(PG_FUNCTION_ARGS)
|
||||
UpdateStats(irelid, buildstate.indtuples);
|
||||
}
|
||||
|
||||
freeGISTstate( &buildstate.giststate );
|
||||
#ifdef GISTDEBUG
|
||||
gist_dumptree(index, 0, GISTP_ROOT, 0);
|
||||
#endif
|
||||
@ -253,7 +248,7 @@ gistbuildCallback(Relation index,
|
||||
(Relation) NULL, (Page) NULL, (OffsetNumber) 0,
|
||||
-1 /* size is currently bogus */ , TRUE, FALSE);
|
||||
if (attdata[i] != tmpcentry.key &&
|
||||
!(buildstate->giststate.attbyval[i]))
|
||||
!( isAttByVal(&buildstate->giststate, i)))
|
||||
compvec[i] = TRUE;
|
||||
else
|
||||
compvec[i] = FALSE;
|
||||
@ -262,7 +257,7 @@ gistbuildCallback(Relation index,
|
||||
}
|
||||
|
||||
/* form an index tuple and point it at the heap tuple */
|
||||
itup = index_formtuple(RelationGetDescr(index), attdata, nulls);
|
||||
itup = index_formtuple(buildstate->giststate.tupdesc, attdata, nulls);
|
||||
itup->t_tid = htup->t_self;
|
||||
|
||||
/*
|
||||
@ -330,14 +325,14 @@ gistinsert(PG_FUNCTION_ARGS)
|
||||
gistcentryinit(&giststate, i, &tmpentry, datum[i],
|
||||
(Relation) NULL, (Page) NULL, (OffsetNumber) 0,
|
||||
-1 /* size is currently bogus */ , TRUE, FALSE );
|
||||
if (datum[i] != tmpentry.key && !(giststate.attbyval[i]))
|
||||
if (datum[i] != tmpentry.key && !( isAttByVal( &giststate, i)))
|
||||
compvec[i] = TRUE;
|
||||
else
|
||||
compvec[i] = FALSE;
|
||||
datum[i] = tmpentry.key;
|
||||
}
|
||||
}
|
||||
itup = index_formtuple(RelationGetDescr(r), datum, nulls);
|
||||
itup = index_formtuple(giststate.tupdesc, datum, nulls);
|
||||
itup->t_tid = *ht_ctid;
|
||||
|
||||
res = (InsertIndexResult) palloc(sizeof(InsertIndexResultData));
|
||||
@ -347,6 +342,7 @@ gistinsert(PG_FUNCTION_ARGS)
|
||||
if (compvec[i] == TRUE)
|
||||
pfree(DatumGetPointer(datum[i]));
|
||||
pfree(itup);
|
||||
freeGISTstate( &giststate );
|
||||
|
||||
PG_RETURN_POINTER(res);
|
||||
}
|
||||
@ -663,15 +659,15 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
|
||||
for (j = 0; j < r->rd_att->natts; j++) {
|
||||
reallen=0;
|
||||
for (i = 0; i < len; i++) {
|
||||
datum = index_getattr(itvec[i], j+1, r->rd_att, &IsNull);
|
||||
datum = index_getattr(itvec[i], j+1, giststate->tupdesc, &IsNull);
|
||||
if ( IsNull ) continue;
|
||||
|
||||
gistdentryinit(giststate, j,
|
||||
&((GISTENTRY *) VARDATA(evec))[reallen],
|
||||
datum,
|
||||
(Relation) NULL, (Page) NULL, (OffsetNumber) NULL,
|
||||
ATTSIZE( datum, r, j+1, IsNull ), FALSE, IsNull);
|
||||
if ( (!giststate->attbyval[j]) &&
|
||||
ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
|
||||
if ( (!isAttByVal(giststate,j)) &&
|
||||
((GISTENTRY *) VARDATA(evec))[reallen].key != datum )
|
||||
needfree[reallen] = TRUE;
|
||||
else
|
||||
@ -706,7 +702,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
|
||||
datumsize, FALSE, FALSE);
|
||||
isnull[j] = ' ';
|
||||
attr[j] = centry[j].key;
|
||||
if ( !giststate->attbyval[j] ) {
|
||||
if ( !isAttByVal( giststate, j ) ) {
|
||||
whatfree[j] = TRUE;
|
||||
if ( centry[j].key != datum )
|
||||
pfree(DatumGetPointer(datum));
|
||||
@ -718,7 +714,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate) {
|
||||
pfree(evec);
|
||||
pfree(needfree);
|
||||
|
||||
newtup = (IndexTuple) index_formtuple(r->rd_att, attr, isnull);
|
||||
newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
|
||||
for (j = 0; j < r->rd_att->natts; j++)
|
||||
if ( whatfree[j] )
|
||||
pfree(DatumGetPointer(attr[j]));
|
||||
@ -802,7 +798,7 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||
|
||||
isnull[j] = ' ';
|
||||
attr[j] = centry[j].key;
|
||||
if ( (!giststate->attbyval[j]) ) {
|
||||
if ( (!isAttByVal( giststate, j ) ) ) {
|
||||
whatfree[j] = TRUE;
|
||||
if ( centry[j].key != datum )
|
||||
pfree(DatumGetPointer(datum));
|
||||
@ -814,7 +810,7 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||
|
||||
if (neednew) {
|
||||
/* need to update key */
|
||||
newtup = (IndexTuple) index_formtuple(r->rd_att, attr, isnull);
|
||||
newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
|
||||
newtup->t_tid = oldtup->t_tid;
|
||||
}
|
||||
|
||||
@ -861,7 +857,7 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
|
||||
if ( spl->spl_idgrp[ entries[i] ] )
|
||||
continue;
|
||||
datum = index_getattr(itvec[ entries[i]-1 ], j+1,
|
||||
r->rd_att, &IsNull);
|
||||
giststate->tupdesc, &IsNull);
|
||||
if ( IsNull )
|
||||
continue;
|
||||
gistdentryinit(giststate, j,
|
||||
@ -869,8 +865,8 @@ gistunionsubkey( Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLIT
|
||||
datum,
|
||||
(Relation) NULL, (Page) NULL,
|
||||
(OffsetNumber) NULL,
|
||||
ATTSIZE( datum, r, j+1, IsNull ), FALSE, IsNull);
|
||||
if ( (!giststate->attbyval[j]) &&
|
||||
ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
|
||||
if ( (!isAttByVal( giststate, j )) &&
|
||||
((GISTENTRY *) VARDATA(evec))[reallen].key != datum )
|
||||
needfree[reallen] = TRUE;
|
||||
else
|
||||
@ -1064,7 +1060,7 @@ gistadjsubkey(Relation r,
|
||||
PointerGetDatum(evec),
|
||||
PointerGetDatum(&datumsize));
|
||||
|
||||
if ( (!giststate->attbyval[j]) && !v->spl_lisnull[j] )
|
||||
if ( (!isAttByVal( giststate, j )) && !v->spl_lisnull[j] )
|
||||
pfree( DatumGetPointer(v->spl_lattr[j]) );
|
||||
v->spl_lattr[j] = datum;
|
||||
v->spl_lattrsize[j] = datumsize;
|
||||
@ -1089,7 +1085,7 @@ gistadjsubkey(Relation r,
|
||||
PointerGetDatum(evec),
|
||||
PointerGetDatum(&datumsize));
|
||||
|
||||
if ( (!giststate->attbyval[j]) && !v->spl_risnull[j] )
|
||||
if ( (!isAttByVal( giststate, j)) && !v->spl_risnull[j] )
|
||||
pfree( DatumGetPointer(v->spl_rattr[j]) );
|
||||
|
||||
v->spl_rattr[j] = datum;
|
||||
@ -1171,11 +1167,11 @@ gistSplit(Relation r,
|
||||
VARATT_SIZEP(entryvec) = (*len + 1) * sizeof(GISTENTRY) + VARHDRSZ;
|
||||
for (i = 1; i <= *len; i++)
|
||||
{
|
||||
datum = index_getattr(itup[i - 1], 1, r->rd_att, &IsNull);
|
||||
datum = index_getattr(itup[i - 1], 1, giststate->tupdesc, &IsNull);
|
||||
gistdentryinit(giststate, 0,&((GISTENTRY *) VARDATA(entryvec))[i],
|
||||
datum, r, p, i,
|
||||
ATTSIZE( datum, r, 1, IsNull ), FALSE, IsNull);
|
||||
if ( (!giststate->attbyval[0]) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum )
|
||||
ATTSIZE( datum, giststate->tupdesc, 1, IsNull ), FALSE, IsNull);
|
||||
if ( (!isAttByVal(giststate,0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum )
|
||||
decompvec[i] = TRUE;
|
||||
else
|
||||
decompvec[i] = FALSE;
|
||||
@ -1250,7 +1246,7 @@ gistSplit(Relation r,
|
||||
(res && rvectup[nlen - 1] == itup[*len - 1]) ? res : NULL);
|
||||
ReleaseBuffer(rightbuf);
|
||||
for( j=1; j<r->rd_att->natts; j++ )
|
||||
if ( (!giststate->attbyval[j]) && !v.spl_risnull[j] )
|
||||
if ( (!isAttByVal(giststate,j)) && !v.spl_risnull[j] )
|
||||
pfree( DatumGetPointer(v.spl_rattr[j]) );
|
||||
}
|
||||
else
|
||||
@ -1280,7 +1276,7 @@ gistSplit(Relation r,
|
||||
ReleaseBuffer(leftbuf);
|
||||
|
||||
for( j=1; j<r->rd_att->natts; j++ )
|
||||
if ( (!giststate->attbyval[j]) && !v.spl_lisnull[j] )
|
||||
if ( (!isAttByVal(giststate,j)) && !v.spl_lisnull[j] )
|
||||
pfree( DatumGetPointer(v.spl_lattr[j]) );
|
||||
|
||||
newtup = gistjoinvector(newtup, &nlen, lntup, llen);
|
||||
@ -1382,11 +1378,11 @@ gistchoose(Relation r, Page p, IndexTuple it, /* it has compressed entry */
|
||||
IndexTuple itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
|
||||
sum_grow=0;
|
||||
for (j=0; j<r->rd_att->natts; j++) {
|
||||
datum = index_getattr(itup, j+1, r->rd_att, &IsNull);
|
||||
gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE( datum, r, j+1, IsNull ), FALSE, IsNull);
|
||||
datum = index_getattr(itup, j+1, giststate->tupdesc, &IsNull);
|
||||
gistdentryinit(giststate, j, &entry, datum, r, p, i, ATTSIZE( datum, giststate->tupdesc, j+1, IsNull ), FALSE, IsNull);
|
||||
gistpenalty( giststate, j, &entry, IsNull, &identry[j], isnull[j], &usize);
|
||||
|
||||
if ( (!giststate->attbyval[j]) && entry.key != datum)
|
||||
if ( (!isAttByVal(giststate,j)) && entry.key != datum)
|
||||
pfree(DatumGetPointer(entry.key));
|
||||
|
||||
if ( which_grow[j]<0 || usize < which_grow[j] ) {
|
||||
@ -1553,25 +1549,13 @@ initGISTstate(GISTSTATE *giststate, Relation index)
|
||||
penalty_proc,
|
||||
picksplit_proc,
|
||||
equal_proc;
|
||||
HeapTuple itup;
|
||||
HeapTuple ctup;
|
||||
Form_pg_index itupform;
|
||||
Form_pg_opclass opclassform;
|
||||
Oid inputtype;
|
||||
Oid keytype;
|
||||
int i;
|
||||
|
||||
if (index->rd_att->natts > INDEX_MAX_KEYS)
|
||||
elog(ERROR, "initGISTstate: numberOfAttributes %d > %d",
|
||||
index->rd_att->natts, INDEX_MAX_KEYS);
|
||||
|
||||
itup = SearchSysCache(INDEXRELID,
|
||||
ObjectIdGetDatum(RelationGetRelid(index)),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(itup))
|
||||
elog(ERROR, "initGISTstate: index %u not found",
|
||||
RelationGetRelid(index));
|
||||
itupform = (Form_pg_index) GETSTRUCT(itup);
|
||||
giststate->tupdesc = index->rd_att;
|
||||
|
||||
for (i = 0; i < index->rd_att->natts; i++)
|
||||
{
|
||||
@ -1589,36 +1573,12 @@ initGISTstate(GISTSTATE *giststate, Relation index)
|
||||
fmgr_info(penalty_proc, &((giststate->penaltyFn)[i]) );
|
||||
fmgr_info(picksplit_proc, &((giststate->picksplitFn)[i]) );
|
||||
fmgr_info(equal_proc, &((giststate->equalFn)[i]) );
|
||||
|
||||
/* Check opclass entry to see if there is a keytype */
|
||||
ctup = SearchSysCache(CLAOID,
|
||||
ObjectIdGetDatum(itupform->indclass[i]),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(ctup))
|
||||
elog(ERROR, "cache lookup failed for opclass %u",
|
||||
itupform->indclass[i]);
|
||||
opclassform = (Form_pg_opclass) GETSTRUCT(ctup);
|
||||
inputtype = opclassform->opcintype;
|
||||
keytype = opclassform->opckeytype;
|
||||
ReleaseSysCache(ctup);
|
||||
|
||||
if (OidIsValid(keytype))
|
||||
{
|
||||
/* index column type is (possibly) different from input data */
|
||||
giststate->haskeytype[i] = true;
|
||||
giststate->attbyval[i] = get_typbyval(inputtype);
|
||||
giststate->keytypbyval[i] = index->rd_att->attrs[i]->attbyval;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Normal case where index column type is same as input data */
|
||||
giststate->haskeytype[i] = false;
|
||||
giststate->attbyval[i] = index->rd_att->attrs[i]->attbyval;
|
||||
giststate->keytypbyval[i] = false; /* not actually used */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ReleaseSysCache(itup);
|
||||
void
|
||||
freeGISTstate(GISTSTATE *giststate) {
|
||||
/* no work */
|
||||
}
|
||||
|
||||
#ifdef GIST_PAGEADDITEM
|
||||
@ -1678,23 +1638,26 @@ gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e,
|
||||
Datum k, Relation r, Page pg, OffsetNumber o,
|
||||
int b, bool l, bool isNull)
|
||||
{
|
||||
GISTENTRY *dep;
|
||||
|
||||
gistentryinit(*e, k, r, pg, o, b, l);
|
||||
if (giststate->haskeytype[nkey])
|
||||
if ( b && ! isNull )
|
||||
{
|
||||
if ( b && ! isNull ) {
|
||||
dep = (GISTENTRY *)
|
||||
DatumGetPointer(FunctionCall1(&giststate->decompressFn[nkey],
|
||||
GISTENTRY *dep;
|
||||
|
||||
gistentryinit(*e, k, r, pg, o, b, l);
|
||||
dep = (GISTENTRY *)
|
||||
DatumGetPointer(FunctionCall1(&giststate->decompressFn[nkey],
|
||||
PointerGetDatum(e)));
|
||||
gistentryinit(*e, dep->key, dep->rel, dep->page, dep->offset, dep->bytes,
|
||||
dep->leafkey);
|
||||
if (dep != e)
|
||||
pfree(dep);
|
||||
} else {
|
||||
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
|
||||
/* decompressFn may just return the given pointer */
|
||||
if (dep != e)
|
||||
{
|
||||
gistentryinit(*e, dep->key, dep->rel, dep->page, dep->offset,
|
||||
dep->bytes, dep->leafkey);
|
||||
pfree(dep);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1706,23 +1669,26 @@ gistcentryinit(GISTSTATE *giststate, int nkey,
|
||||
GISTENTRY *e, Datum k, Relation r,
|
||||
Page pg, OffsetNumber o, int b, bool l, bool isNull)
|
||||
{
|
||||
GISTENTRY *cep;
|
||||
|
||||
gistentryinit(*e, k, r, pg, o, b, l);
|
||||
if (giststate->haskeytype[nkey])
|
||||
if (!isNull)
|
||||
{
|
||||
if ( ! isNull ) {
|
||||
cep = (GISTENTRY *)
|
||||
DatumGetPointer(FunctionCall1(&giststate->compressFn[nkey],
|
||||
GISTENTRY *cep;
|
||||
|
||||
gistentryinit(*e, k, r, pg, o, b, l);
|
||||
cep = (GISTENTRY *)
|
||||
DatumGetPointer(FunctionCall1(&giststate->compressFn[nkey],
|
||||
PointerGetDatum(e)));
|
||||
/* compressFn may just return the given pointer */
|
||||
if (cep != e)
|
||||
{
|
||||
gistentryinit(*e, cep->key, cep->rel, cep->page, cep->offset,
|
||||
cep->bytes, cep->leafkey);
|
||||
if (cep != e)
|
||||
pfree(cep);
|
||||
} else {
|
||||
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
|
||||
pfree(cep);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
gistentryinit(*e, (Datum) 0, r, pg, o, 0, l);
|
||||
}
|
||||
}
|
||||
|
||||
static IndexTuple
|
||||
@ -1747,7 +1713,7 @@ gistFormTuple( GISTSTATE *giststate, Relation r,
|
||||
datumsize[j], FALSE, FALSE);
|
||||
isnullchar[j] = ' ';
|
||||
compatt[j] = centry[j].key;
|
||||
if ( !giststate->attbyval[j] ) {
|
||||
if ( !isAttByVal(giststate,j) ) {
|
||||
whatfree[j] = TRUE;
|
||||
if ( centry[j].key != attdata[j] )
|
||||
pfree(DatumGetPointer(attdata[j]));
|
||||
@ -1756,7 +1722,7 @@ gistFormTuple( GISTSTATE *giststate, Relation r,
|
||||
}
|
||||
}
|
||||
|
||||
tup = (IndexTuple) index_formtuple(r->rd_att, compatt, isnullchar);
|
||||
tup = (IndexTuple) index_formtuple(giststate->tupdesc, compatt, isnullchar);
|
||||
for (j = 0; j < r->rd_att->natts; j++)
|
||||
if ( whatfree[j] ) pfree(DatumGetPointer(compatt[j]));
|
||||
|
||||
@ -1770,11 +1736,11 @@ gistDeCompressAtt( GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p,
|
||||
Datum datum;
|
||||
|
||||
for(i=0; i < r->rd_att->natts; i++ ) {
|
||||
datum = index_getattr(tuple, i+1, r->rd_att, &isnull[i]);
|
||||
datum = index_getattr(tuple, i+1, giststate->tupdesc, &isnull[i]);
|
||||
gistdentryinit(giststate, i, &attdata[i],
|
||||
datum, r, p, o,
|
||||
ATTSIZE( datum, r, i+1, isnull[i] ), FALSE, isnull[i]);
|
||||
if ( giststate->attbyval[i] )
|
||||
ATTSIZE( datum, giststate->tupdesc, i+1, isnull[i] ), FALSE, isnull[i]);
|
||||
if ( isAttByVal(giststate,i) )
|
||||
decompvec[i] = FALSE;
|
||||
else {
|
||||
if (attdata[i].key == datum || isnull[i] )
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.29 2001/08/10 14:34:28 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistget.c,v 1.30 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -239,7 +239,7 @@ gistindex_keytest(IndexTuple tuple,
|
||||
{
|
||||
datum = index_getattr(tuple,
|
||||
key[0].sk_attno,
|
||||
tupdesc,
|
||||
giststate->tupdesc,
|
||||
&isNull);
|
||||
if (isNull)
|
||||
{
|
||||
@ -271,7 +271,7 @@ gistindex_keytest(IndexTuple tuple,
|
||||
ObjectIdGetDatum(key[0].sk_procedure));
|
||||
}
|
||||
|
||||
if ( de.key != datum )
|
||||
if ( de.key != datum && ! isAttByVal( giststate, key[0].sk_attno-1 ) )
|
||||
if ( DatumGetPointer(de.key) != NULL )
|
||||
pfree( DatumGetPointer(de.key) );
|
||||
|
||||
|
@ -8,7 +8,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.38 2001/07/15 22:48:15 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/access/gist/gistscan.c,v 1.39 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -234,6 +234,8 @@ gistendscan(PG_FUNCTION_ARGS)
|
||||
{
|
||||
gistfreestack(p->s_stack);
|
||||
gistfreestack(p->s_markstk);
|
||||
if ( p->giststate != NULL )
|
||||
freeGISTstate( p->giststate );
|
||||
pfree(s->opaque);
|
||||
}
|
||||
|
||||
|
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.161 2001/08/21 16:36:00 tgl Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.162 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*
|
||||
* INTERFACE ROUTINES
|
||||
@ -33,6 +33,7 @@
|
||||
#include "catalog/index.h"
|
||||
#include "catalog/indexing.h"
|
||||
#include "catalog/pg_index.h"
|
||||
#include "catalog/pg_opclass.h"
|
||||
#include "catalog/pg_proc.h"
|
||||
#include "catalog/pg_type.h"
|
||||
#include "commands/comment.h"
|
||||
@ -62,9 +63,11 @@
|
||||
/* non-export function prototypes */
|
||||
static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName,
|
||||
bool istemp);
|
||||
static TupleDesc BuildFuncTupleDesc(Oid funcOid);
|
||||
static TupleDesc BuildFuncTupleDesc(Oid funcOid,
|
||||
Oid *classObjectId);
|
||||
static TupleDesc ConstructTupleDescriptor(Relation heapRelation,
|
||||
int numatts, AttrNumber *attNums);
|
||||
int numatts, AttrNumber *attNums,
|
||||
Oid *classObjectId);
|
||||
static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
|
||||
static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname);
|
||||
static void InitializeAttributeOids(Relation indexRelation,
|
||||
@ -124,11 +127,14 @@ GetHeapRelationOid(char *heapRelationName, char *indexRelationName, bool istemp)
|
||||
}
|
||||
|
||||
static TupleDesc
|
||||
BuildFuncTupleDesc(Oid funcOid)
|
||||
BuildFuncTupleDesc(Oid funcOid,
|
||||
Oid *classObjectId)
|
||||
{
|
||||
TupleDesc funcTupDesc;
|
||||
HeapTuple tuple;
|
||||
Oid keyType;
|
||||
Oid retType;
|
||||
Form_pg_type typeTup;
|
||||
|
||||
/*
|
||||
* Allocate and zero a tuple descriptor for a one-column tuple.
|
||||
@ -156,25 +162,41 @@ BuildFuncTupleDesc(Oid funcOid)
|
||||
ReleaseSysCache(tuple);
|
||||
|
||||
/*
|
||||
* Lookup the return type in pg_type for the type length etc.
|
||||
* Check the opclass to see if it provides a keytype (overriding the
|
||||
* function result type).
|
||||
*/
|
||||
tuple = SearchSysCache(TYPEOID,
|
||||
ObjectIdGetDatum(retType),
|
||||
tuple = SearchSysCache(CLAOID,
|
||||
ObjectIdGetDatum(classObjectId[0]),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "Type %u does not exist", retType);
|
||||
elog(ERROR, "Opclass %u does not exist", classObjectId[0]);
|
||||
keyType = ((Form_pg_opclass) GETSTRUCT(tuple))->opckeytype;
|
||||
ReleaseSysCache(tuple);
|
||||
|
||||
if (!OidIsValid(keyType))
|
||||
keyType = retType;
|
||||
|
||||
/*
|
||||
* Lookup the key type in pg_type for the type length etc.
|
||||
*/
|
||||
tuple = SearchSysCache(TYPEOID,
|
||||
ObjectIdGetDatum(keyType),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "Type %u does not exist", keyType);
|
||||
typeTup = (Form_pg_type) GETSTRUCT(tuple);
|
||||
|
||||
/*
|
||||
* Assign some of the attributes values. Leave the rest as 0.
|
||||
*/
|
||||
funcTupDesc->attrs[0]->attlen = ((Form_pg_type) GETSTRUCT(tuple))->typlen;
|
||||
funcTupDesc->attrs[0]->atttypid = retType;
|
||||
funcTupDesc->attrs[0]->attnum = 1;
|
||||
funcTupDesc->attrs[0]->attbyval = ((Form_pg_type) GETSTRUCT(tuple))->typbyval;
|
||||
funcTupDesc->attrs[0]->atttypid = keyType;
|
||||
funcTupDesc->attrs[0]->attlen = typeTup->typlen;
|
||||
funcTupDesc->attrs[0]->attbyval = typeTup->typbyval;
|
||||
funcTupDesc->attrs[0]->attcacheoff = -1;
|
||||
funcTupDesc->attrs[0]->atttypmod = -1;
|
||||
funcTupDesc->attrs[0]->attstorage = ((Form_pg_type) GETSTRUCT(tuple))->typstorage;
|
||||
funcTupDesc->attrs[0]->attalign = ((Form_pg_type) GETSTRUCT(tuple))->typalign;
|
||||
funcTupDesc->attrs[0]->attstorage = typeTup->typstorage;
|
||||
funcTupDesc->attrs[0]->attalign = typeTup->typalign;
|
||||
|
||||
ReleaseSysCache(tuple);
|
||||
|
||||
@ -190,7 +212,8 @@ BuildFuncTupleDesc(Oid funcOid)
|
||||
static TupleDesc
|
||||
ConstructTupleDescriptor(Relation heapRelation,
|
||||
int numatts,
|
||||
AttrNumber *attNums)
|
||||
AttrNumber *attNums,
|
||||
Oid *classObjectId)
|
||||
{
|
||||
TupleDesc heapTupDesc;
|
||||
TupleDesc indexTupDesc;
|
||||
@ -217,6 +240,8 @@ ConstructTupleDescriptor(Relation heapRelation,
|
||||
AttrNumber atnum; /* attributeNumber[attributeOffset] */
|
||||
Form_pg_attribute from;
|
||||
Form_pg_attribute to;
|
||||
HeapTuple tuple;
|
||||
Oid keyType;
|
||||
|
||||
/*
|
||||
* get the attribute number and make sure it's valid; determine
|
||||
@ -269,6 +294,40 @@ ConstructTupleDescriptor(Relation heapRelation,
|
||||
* fix it later.
|
||||
*/
|
||||
to->attrelid = InvalidOid;
|
||||
|
||||
/*
|
||||
* Check the opclass to see if it provides a keytype (overriding
|
||||
* the attribute type).
|
||||
*/
|
||||
tuple = SearchSysCache(CLAOID,
|
||||
ObjectIdGetDatum(classObjectId[i]),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "Opclass %u does not exist", classObjectId[i]);
|
||||
keyType = ((Form_pg_opclass) GETSTRUCT(tuple))->opckeytype;
|
||||
ReleaseSysCache(tuple);
|
||||
|
||||
if (OidIsValid(keyType) && keyType != to->atttypid)
|
||||
{
|
||||
/* index value and heap value have different types */
|
||||
Form_pg_type typeTup;
|
||||
|
||||
tuple = SearchSysCache(TYPEOID,
|
||||
ObjectIdGetDatum(keyType),
|
||||
0, 0, 0);
|
||||
if (!HeapTupleIsValid(tuple))
|
||||
elog(ERROR, "Type %u does not exist", keyType);
|
||||
typeTup = (Form_pg_type) GETSTRUCT(tuple);
|
||||
|
||||
to->atttypid = keyType;
|
||||
to->atttypmod = -1;
|
||||
to->attlen = typeTup->typlen;
|
||||
to->attbyval = typeTup->typbyval;
|
||||
to->attalign = typeTup->typalign;
|
||||
to->attstorage = typeTup->typstorage;
|
||||
|
||||
ReleaseSysCache(tuple);
|
||||
}
|
||||
}
|
||||
|
||||
return indexTupDesc;
|
||||
@ -703,19 +762,21 @@ index_create(char *heapRelationName,
|
||||
heapRelation = heap_open(heapoid, ShareLock);
|
||||
|
||||
/*
|
||||
* construct new tuple descriptor
|
||||
* construct tuple descriptor for index tuples
|
||||
*/
|
||||
if (OidIsValid(indexInfo->ii_FuncOid))
|
||||
indexTupDesc = BuildFuncTupleDesc(indexInfo->ii_FuncOid);
|
||||
indexTupDesc = BuildFuncTupleDesc(indexInfo->ii_FuncOid,
|
||||
classObjectId);
|
||||
else
|
||||
indexTupDesc = ConstructTupleDescriptor(heapRelation,
|
||||
indexInfo->ii_NumKeyAttrs,
|
||||
indexInfo->ii_KeyAttrNumbers);
|
||||
indexInfo->ii_KeyAttrNumbers,
|
||||
classObjectId);
|
||||
|
||||
if (istemp)
|
||||
{
|
||||
/* save user relation name because heap_create changes it */
|
||||
temp_relname = pstrdup(indexRelationName); /* save original value */
|
||||
temp_relname = pstrdup(indexRelationName); /* save original */
|
||||
indexRelationName = palloc(NAMEDATALEN);
|
||||
strcpy(indexRelationName, temp_relname); /* heap_create will
|
||||
* change this */
|
||||
|
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $Id: gist.h,v 1.31 2001/08/21 16:36:05 tgl Exp $
|
||||
* $Id: gist.h,v 1.32 2001/08/22 18:24:26 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -72,11 +72,11 @@ typedef struct GISTSTATE
|
||||
FmgrInfo penaltyFn[INDEX_MAX_KEYS];
|
||||
FmgrInfo picksplitFn[INDEX_MAX_KEYS];
|
||||
FmgrInfo equalFn[INDEX_MAX_KEYS];
|
||||
bool attbyval[INDEX_MAX_KEYS];
|
||||
bool haskeytype[INDEX_MAX_KEYS];
|
||||
bool keytypbyval[INDEX_MAX_KEYS];
|
||||
|
||||
TupleDesc tupdesc;
|
||||
} GISTSTATE;
|
||||
|
||||
#define isAttByVal( gs, anum ) (gs)->tupdesc->attrs[anum]->attbyval
|
||||
|
||||
/*
|
||||
* When we're doing a scan, we need to keep track of the parent stack
|
||||
@ -169,6 +169,7 @@ extern Datum gistbulkdelete(PG_FUNCTION_ARGS);
|
||||
extern void _gistdump(Relation r);
|
||||
extern void gistfreestack(GISTSTACK *s);
|
||||
extern void initGISTstate(GISTSTATE *giststate, Relation index);
|
||||
extern void freeGISTstate(GISTSTATE *giststate);
|
||||
extern void gistdentryinit(GISTSTATE *giststate, int nkey, GISTENTRY *e,
|
||||
Datum k, Relation r, Page pg, OffsetNumber o,
|
||||
int b, bool l, bool isNull);
|
||||
|
Loading…
Reference in New Issue
Block a user