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';
'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
'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
(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
-------
(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
-------
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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
*/
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 );
** 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
** 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));
** 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);
*result = DatumGetBool( DirectFunctionCall2( box_same, PointerGetDatum(b1), PointerGetDatum(b2)) );
else
*result = ( b1==NULL && b2==NULL ) ? TRUE : FALSE;
- return(result);
+ PG_RETURN_POINTER(result);
}
/*
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 ) {
* Polygon ops
**************************************************/
-GISTENTRY *
+Datum
gpoly_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry=(GISTENTRY*)PG_GETARG_POINTER(0);
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,
} 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,
** 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));
}
(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
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
-- 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')
-- 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')
-- 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')
-- 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')
-- 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')
-- 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')
-- 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')
-- 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')
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
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
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
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;
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;
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;
* 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 $
*
*-------------------------------------------------------------------------
*/
#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 */
UpdateStats(irelid, buildstate.indtuples);
}
+ freeGISTstate( &buildstate.giststate );
#ifdef GISTDEBUG
gist_dumptree(index, 0, GISTP_ROOT, 0);
#endif
(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;
}
/* 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;
/*
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));
if (compvec[i] == TRUE)
pfree(DatumGetPointer(datum[i]));
pfree(itup);
+ freeGISTstate( &giststate );
PG_RETURN_POINTER(res);
}
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
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));
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]));
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));
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;
}
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,
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
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;
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;
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;
(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
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);
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] ) {
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++)
{
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
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);
+ }
}
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
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]));
}
}
- 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]));
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] )
* 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 $
*
*-------------------------------------------------------------------------
*/
{
datum = index_getattr(tuple,
key[0].sk_attno,
- tupdesc,
+ giststate->tupdesc,
&isNull);
if (isNull)
{
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) );
* 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 $
*
*-------------------------------------------------------------------------
*/
{
gistfreestack(p->s_stack);
gistfreestack(p->s_markstk);
+ if ( p->giststate != NULL )
+ freeGISTstate( p->giststate );
pfree(s->opaque);
}
*
*
* 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
#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"
/* 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,
}
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.
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(CLAOID,
+ ObjectIdGetDatum(classObjectId[0]),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ 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(retType),
+ ObjectIdGetDatum(keyType),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "Type %u does not exist", retType);
+ 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);
static TupleDesc
ConstructTupleDescriptor(Relation heapRelation,
int numatts,
- AttrNumber *attNums)
+ AttrNumber *attNums,
+ Oid *classObjectId)
{
TupleDesc heapTupDesc;
TupleDesc indexTupDesc;
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
* 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;
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
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
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);
projects / postgresql / commitdiff