- SETBIT( sign, (*a)%SIGLENBIT );
- a++;
- }
+static void
+gensign(BITVEC sign, int *a, int len)
+{
+ int i;
+
+ /* we assume that the sign vector is previously zeroed */
+ for (i = 0; i < len; i++)
+ {
+ SETBIT(sign, (*a) % SIGLENBIT);
+ a++;
+ }
}
-static bool
-_intbig_overlap(ArrayType *a, ArrayType *b) {
- int i;
- BITVECP da, db;
-
- if ( ARRISNULL( a ) || ARRISNULL( b ) ) return FALSE;
+static bool
+_intbig_overlap(ArrayType *a, ArrayType *b)
+{
+ int i;
+ BITVECP da,
+ db;
+
+ if (ARRISNULL(a) || ARRISNULL(b))
+ return FALSE;
da = SIGPTR(a);
db = SIGPTR(b);
- LOOPBYTE( if ( da[i] & db[i] ) return TRUE );
+ LOOPBYTE(if (da[i] & db[i]) return TRUE);
return FALSE;
}
-static bool
-_intbig_contains(ArrayType *a, ArrayType *b) {
- int i;
- BITVECP da, db;
-
- if ( ARRISNULL( a ) || ARRISNULL( b ) ) return FALSE;
+static bool
+_intbig_contains(ArrayType *a, ArrayType *b)
+{
+ int i;
+ BITVECP da,
+ db;
+
+ if (ARRISNULL(a) || ARRISNULL(b))
+ return FALSE;
da = SIGPTR(a);
db = SIGPTR(b);
- LOOPBYTE( if ( db[i] & ~da[i] ) return FALSE );
+ LOOPBYTE(if (db[i] & ~da[i]) return FALSE);
return TRUE;
}
-static void
-rt__intbig_size(ArrayType *a, float* sz) {
- int i, len=0;
- BITVECP bv;
+static void
+rt__intbig_size(ArrayType *a, float *sz)
+{
+ int i,
+ len = 0;
+ BITVECP bv;
- if ( ARRISNULL( a ) ) {
- *sz=0.0;
+ if (ARRISNULL(a))
+ {
+ *sz = 0.0;
return;
}
bv = SIGPTR(a);
- LOOPBIT( len += GETBIT(bv, i) );
+ LOOPBIT(len += GETBIT(bv, i));
*sz = (float) len;
return;
}
-static ArrayType *
-_intbig_union(ArrayType *a, ArrayType *b) {
- ArrayType * r;
- BITVECP da, db, dr;
- int i;
-
- if ( ARRISNULL( a ) && ARRISNULL( b ) ) return new_intArrayType(0);
- if ( ARRISNULL( a ) ) return copy_intArrayType( b );
- if ( ARRISNULL( b ) ) return copy_intArrayType( a );
-
- r = new_intArrayType( SIGLENINT );
+static ArrayType *
+_intbig_union(ArrayType *a, ArrayType *b)
+{
+ ArrayType *r;
+ BITVECP da,
+ db,
+ dr;
+ int i;
+
+ if (ARRISNULL(a) && ARRISNULL(b))
+ return new_intArrayType(0);
+ if (ARRISNULL(a))
+ return copy_intArrayType(b);
+ if (ARRISNULL(b))
+ return copy_intArrayType(a);
+
+ r = new_intArrayType(SIGLENINT);
da = SIGPTR(a);
db = SIGPTR(b);
LOOPBYTE(dr[i] = da[i] | db[i]);
- return r;
-}
+ return r;
+}
-static ArrayType *
-_intbig_inter(ArrayType *a, ArrayType *b) {
- ArrayType * r;
- BITVECP da, db, dr;
- int i;
+static ArrayType *
+_intbig_inter(ArrayType *a, ArrayType *b)
+{
+ ArrayType *r;
+ BITVECP da,
+ db,
+ dr;
+ int i;
- if ( ARRISNULL( a ) || ARRISNULL( b ) ) return new_intArrayType(0);
+ if (ARRISNULL(a) || ARRISNULL(b))
+ return new_intArrayType(0);
- r = new_intArrayType( SIGLENINT );
+ r = new_intArrayType(SIGLENINT);
da = SIGPTR(a);
db = SIGPTR(b);
LOOPBYTE(dr[i] = da[i] & db[i]);
- return r;
-}
+ return r;
+}
bool *
-g_intbig_same(ArrayType *a, ArrayType *b, bool *result) {
- BITVECP da, db;
- int i;
+g_intbig_same(ArrayType *a, ArrayType *b, bool *result)
+{
+ BITVECP da,
+ db;
+ int i;
- if ( ARRISNULL( a ) || ARRISNULL( b ) ) {
- *result = ( ARRISNULL( a ) && ARRISNULL( b ) ) ? TRUE : FALSE;
+ if (ARRISNULL(a) || ARRISNULL(b))
+ {
+ *result = (ARRISNULL(a) && ARRISNULL(b)) ? TRUE : FALSE;
return result;
}
db = SIGPTR(b);
LOOPBYTE(
- if ( da[i] != db[i] ) {
- *result = FALSE;
- return result;
- }
+ if (da[i] != db[i])
+ {
+ *result = FALSE;
+ return result;
+ }
);
*result = TRUE;
return result;
}
-GISTENTRY *
-g_intbig_compress(GISTENTRY *entry) {
- GISTENTRY *retval;
- ArrayType *r, *in;
+GISTENTRY *
+g_intbig_compress(GISTENTRY *entry)
+{
+ GISTENTRY *retval;
+ ArrayType *r,
+ *in;
+
#ifdef PGSQL71
- if ( entry->pred )
- in = (ArrayType *)PG_DETOAST_DATUM( entry->pred );
- else
+ if (entry->pred)
+ in = (ArrayType *) PG_DETOAST_DATUM(entry->pred);
+ else
in = NULL;
#else
in = (ArrayType *) entry->pred;
#endif
- if ( ! entry->leafkey ) return entry;
-
+ if (!entry->leafkey)
+ return entry;
+
retval = palloc(sizeof(GISTENTRY));
- if ( ARRISNULL( in ) ) {
-#ifdef PGSQL71
- if ( in ) if ( (char*)in != (char*)entry->pred ) pfree(in);
+ if (ARRISNULL(in))
+ {
+#ifdef PGSQL71
+ if (in)
+ if ((char *) in != (char *) entry->pred)
+ pfree(in);
#endif
- gistentryinit(*retval, (char *)NULL, entry->rel, entry->page, entry->offset,0, FALSE);
- return( retval );
+ gistentryinit(*retval, (char *) NULL, entry->rel, entry->page, entry->offset, 0, FALSE);
+ return (retval);
}
-
- r = new_intArrayType( SIGLENINT );
- gensign( SIGPTR( r ),
- ARRPTR ( in ),
- ARRNELEMS( in ) );
-
- gistentryinit(*retval, (char *)r, entry->rel, entry->page, entry->offset, VARSIZE( r ), FALSE);
-
-#ifdef PGSQL71
- if ( in ) if ( (char*)in != (char*)entry->pred ) pfree(in);
+
+ r = new_intArrayType(SIGLENINT);
+ gensign(SIGPTR(r),
+ ARRPTR(in),
+ ARRNELEMS(in));
+
+ gistentryinit(*retval, (char *) r, entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
+
+#ifdef PGSQL71
+ if (in)
+ if ((char *) in != (char *) entry->pred)
+ pfree(in);
#endif
- return(retval);
+ return (retval);
}
-GISTENTRY *
-g_intbig_decompress(GISTENTRY *entry) {
+GISTENTRY *
+g_intbig_decompress(GISTENTRY *entry)
+{
#ifdef PGSQL71
- ArrayType *key;
- key = (ArrayType *)PG_DETOAST_DATUM( entry->pred );
- if ( (char*)key != (char*)entry->pred ) {
- GISTENTRY *retval;
+ ArrayType *key;
+
+ key = (ArrayType *) PG_DETOAST_DATUM(entry->pred);
+ if ((char *) key != (char *) entry->pred)
+ {
+ GISTENTRY *retval;
+
retval = palloc(sizeof(GISTENTRY));
- gistentryinit(*retval, (char *)key, entry->rel, entry->page, entry->offset, VARSIZE( key ), FALSE);
+ gistentryinit(*retval, (char *) key, entry->rel, entry->page, entry->offset, VARSIZE(key), FALSE);
return retval;
}
#endif
return entry;
}
-GIST_SPLITVEC *
-g_intbig_picksplit(bytea *entryvec, GIST_SPLITVEC *v) {
- return _int_common_picksplit( entryvec, v,
- _intbig_union,
- _intbig_inter,
- rt__intbig_size,
- 1.0);
+GIST_SPLITVEC *
+g_intbig_picksplit(bytea *entryvec, GIST_SPLITVEC *v)
+{
+ return _int_common_picksplit(entryvec, v,
+ _intbig_union,
+ _intbig_inter,
+ rt__intbig_size,
+ 1.0);
}
-ArrayType *
-g_intbig_union(bytea *entryvec, int *sizep) {
- return _int_common_union( entryvec, sizep, _intbig_union );
+ArrayType *
+g_intbig_union(bytea *entryvec, int *sizep)
+{
+ return _int_common_union(entryvec, sizep, _intbig_union);
}
-float *
-g_intbig_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result){
- _int_common_penalty( origentry, newentry, result, _intbig_union, rt__intbig_size);
- return result;
+float *
+g_intbig_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
+{
+ _int_common_penalty(origentry, newentry, result, _intbig_union, rt__intbig_size);
+ return result;
}
-bool
-g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy) {
- bool retval;
- ArrayType * q;
+bool
+g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy)
+{
+ bool retval;
+ ArrayType *q;
/* XXX what about toasted input? */
- if ( ARRISNULL( query ) ) return FALSE;
-
- q = new_intArrayType( SIGLENINT );
- gensign( SIGPTR( q ),
- ARRPTR( query ),
- ARRNELEMS( query ) );
-
- switch(strategy) {
- case RTOverlapStrategyNumber:
- retval = (bool)_intbig_overlap((ArrayType *)(entry->pred), q);
- break;
- case RTSameStrategyNumber:
- case RTContainsStrategyNumber:
- retval = (bool)_intbig_contains((ArrayType *)(entry->pred), q);
- break;
- case RTContainedByStrategyNumber:
- retval = (bool)_intbig_overlap((ArrayType *)(entry->pred), q);
- break;
- default:
- retval = FALSE;
- }
- pfree( q );
- return(retval);
+ if (ARRISNULL(query))
+ return FALSE;
+
+ q = new_intArrayType(SIGLENINT);
+ gensign(SIGPTR(q),
+ ARRPTR(query),
+ ARRNELEMS(query));
+
+ switch (strategy)
+ {
+ case RTOverlapStrategyNumber:
+ retval = (bool) _intbig_overlap((ArrayType *) (entry->pred), q);
+ break;
+ case RTSameStrategyNumber:
+ case RTContainsStrategyNumber:
+ retval = (bool) _intbig_contains((ArrayType *) (entry->pred), q);
+ break;
+ case RTContainedByStrategyNumber:
+ retval = (bool) _intbig_overlap((ArrayType *) (entry->pred), q);
+ break;
+ default:
+ retval = FALSE;
+ }
+ pfree(q);
+ return (retval);
}
/*****************************************************************
** The GiST Union method for _intments
** returns the minimal set that encloses all the entries in entryvec
*/
-ArrayType *
-_int_common_union(bytea *entryvec, int *sizep, formarray unionf) {
- int numranges, i;
- ArrayType *out = (ArrayType *)NULL;
- ArrayType *tmp;
+ArrayType *
+_int_common_union(bytea *entryvec, int *sizep, formarray unionf)
+{
+ int numranges,
+ i;
+ ArrayType *out = (ArrayType *) NULL;
+ ArrayType *tmp;
+
#ifdef GIST_DEBUG
- elog(NOTICE, "_int_common_union in");
+ elog(NOTICE, "_int_common_union in");
#endif
-
- numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY);
- tmp = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred;
-
- for (i = 1; i < numranges; i++) {
- out = (*unionf)(tmp, (ArrayType *)
- (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred);
- if (i > 1 && tmp) pfree(tmp);
- tmp = out;
- }
-
- *sizep = VARSIZE( out );
- if ( *sizep == 0 ) {
- pfree( out );
+
+ numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
+ tmp = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[0]).pred;
+
+ for (i = 1; i < numranges; i++)
+ {
+ out = (*unionf) (tmp, (ArrayType *)
+ (((GISTENTRY *) (VARDATA(entryvec)))[i]).pred);
+ if (i > 1 && tmp)
+ pfree(tmp);
+ tmp = out;
+ }
+
+ *sizep = VARSIZE(out);
+ if (*sizep == 0)
+ {
+ pfree(out);
#ifdef GIST_DEBUG
- elog(NOTICE, "_int_common_union out1");
+ elog(NOTICE, "_int_common_union out1");
#endif
- return NULL;
- }
+ return NULL;
+ }
#ifdef GIST_DEBUG
- elog(NOTICE, "_int_common_union out");
+ elog(NOTICE, "_int_common_union out");
#endif
- return(out);
+ return (out);
}
float *
_int_common_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result,
- formarray unionf,
- formfloat sizef)
+ formarray unionf,
+ formfloat sizef)
{
- Datum ud;
- float tmp1, tmp2;
-
+ Datum ud;
+ float tmp1,
+ tmp2;
+
#ifdef GIST_DEBUG
- elog(NOTICE, "penalty");
+ elog(NOTICE, "penalty");
#endif
- ud = (Datum)(*unionf)((ArrayType *)(origentry->pred), (ArrayType *)(newentry->pred));
- (*sizef)((ArrayType *)ud, &tmp1);
- (*sizef)((ArrayType *)(origentry->pred), &tmp2);
- *result = tmp1 - tmp2;
- pfree((char *)ud);
+ ud = (Datum) (*unionf) ((ArrayType *) (origentry->pred), (ArrayType *) (newentry->pred));
+ (*sizef) ((ArrayType *) ud, &tmp1);
+ (*sizef) ((ArrayType *) (origentry->pred), &tmp2);
+ *result = tmp1 - tmp2;
+ pfree((char *) ud);
#ifdef GIST_DEBUG
- elog(NOTICE, "--penalty\t%g", *result);
+ elog(NOTICE, "--penalty\t%g", *result);
#endif
- return(result);
+ return (result);
}
/*
** The GiST PickSplit method for _intments
-** We use Guttman's poly time split algorithm
+** We use Guttman's poly time split algorithm
*/
GIST_SPLITVEC *
_int_common_picksplit(bytea *entryvec,
- GIST_SPLITVEC *v,
- formarray unionf,
- formarray interf,
- formfloat sizef,
- float coef)
+ GIST_SPLITVEC *v,
+ formarray unionf,
+ formarray interf,
+ formfloat sizef,
+ float coef)
{
- OffsetNumber i, j;
- ArrayType *datum_alpha, *datum_beta;
- ArrayType *datum_l, *datum_r;
- ArrayType *union_d, *union_dl, *union_dr;
- ArrayType *inter_d;
- bool firsttime;
- float size_alpha, size_beta, size_union, size_inter;
- float size_waste, waste;
- float size_l, size_r;
- int nbytes;
- OffsetNumber seed_1 = 0, seed_2 = 0;
- OffsetNumber *left, *right;
- OffsetNumber maxoff;
+ OffsetNumber i,
+ j;
+ ArrayType *datum_alpha,
+ *datum_beta;
+ ArrayType *datum_l,
+ *datum_r;
+ ArrayType *union_d,
+ *union_dl,
+ *union_dr;
+ ArrayType *inter_d;
+ bool firsttime;
+ float size_alpha,
+ size_beta,
+ size_union,
+ size_inter;
+ float size_waste,
+ waste;
+ float size_l,
+ size_r;
+ int nbytes;
+ OffsetNumber seed_1 = 0,
+ seed_2 = 0;
+ OffsetNumber *left,
+ *right;
+ OffsetNumber maxoff;
#ifdef GIST_DEBUG
- elog(NOTICE, "--------picksplit %d",(VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY));
+ elog(NOTICE, "--------picksplit %d", (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY));
#endif
- 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 = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
- for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j)) {
- datum_beta = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[j].pred);
-
- /* compute the wasted space by unioning these guys */
- /* size_waste = size_union - size_inter; */
- union_d = (*unionf)(datum_alpha, datum_beta);
- (*sizef)(union_d, &size_union);
- inter_d = (*interf)(datum_alpha, datum_beta);
- (*sizef)(inter_d, &size_inter);
- size_waste = size_union - size_inter;
-
- pfree(union_d);
-
- if (inter_d != (ArrayType *) NULL)
- pfree(inter_d);
-
- /*
- * 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;
- }
+ 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 = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+ for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
+ {
+ datum_beta = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[j].pred);
+
+ /* compute the wasted space by unioning these guys */
+ /* size_waste = size_union - size_inter; */
+ union_d = (*unionf) (datum_alpha, datum_beta);
+ (*sizef) (union_d, &size_union);
+ inter_d = (*interf) (datum_alpha, datum_beta);
+ (*sizef) (inter_d, &size_inter);
+ size_waste = size_union - size_inter;
+
+ pfree(union_d);
+
+ if (inter_d != (ArrayType *) NULL)
+ pfree(inter_d);
+
+ /*
+ * 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;
-
- datum_alpha = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_1].pred);
- datum_l = copy_intArrayType( datum_alpha );
- (*sizef)((ArrayType *)datum_l, &size_l);
- datum_beta = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[seed_2].pred);
- datum_r = copy_intArrayType( datum_beta );
- (*sizef)((ArrayType *)datum_r, &size_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)) {
-
-
+
+ left = v->spl_left;
+ v->spl_nleft = 0;
+ right = v->spl_right;
+ v->spl_nright = 0;
+
+ datum_alpha = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_1].pred);
+ datum_l = copy_intArrayType(datum_alpha);
+ (*sizef) ((ArrayType *) datum_l, &size_l);
+ datum_beta = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[seed_2].pred);
+ datum_r = copy_intArrayType(datum_beta);
+ (*sizef) ((ArrayType *) datum_r, &size_r);
+
/*
- * 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.
+ * 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.
*/
-
- 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 = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[i].pred);
- union_dl = (ArrayType *)(*unionf)(datum_l, datum_alpha);
- union_dr = (ArrayType *)(*unionf)(datum_r, datum_alpha);
- (*sizef)((ArrayType *)union_dl, &size_alpha);
- (*sizef)((ArrayType *)union_dr, &size_beta);
-
- /* pick which page to add it to */
- if (size_alpha - size_l < size_beta - size_r + WISH_F(v->spl_nleft, v->spl_nright, coef)) {
- if ( datum_l ) pfree(datum_l);
- if ( union_dr ) pfree(union_dr);
- datum_l = union_dl;
- size_l = size_alpha;
- *left++ = i;
- v->spl_nleft++;
- } else {
- if ( datum_r ) pfree(datum_r);
- if ( union_dl ) pfree(union_dl);
- datum_r = union_dr;
- size_r = size_beta;
- *right++ = i;
- v->spl_nright++;
+
+ 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 = (ArrayType *) (((GISTENTRY *) (VARDATA(entryvec)))[i].pred);
+ union_dl = (ArrayType *) (*unionf) (datum_l, datum_alpha);
+ union_dr = (ArrayType *) (*unionf) (datum_r, datum_alpha);
+ (*sizef) ((ArrayType *) union_dl, &size_alpha);
+ (*sizef) ((ArrayType *) union_dr, &size_beta);
+
+ /* pick which page to add it to */
+ if (size_alpha - size_l < size_beta - size_r + WISH_F(v->spl_nleft, v->spl_nright, coef))
+ {
+ if (datum_l)
+ pfree(datum_l);
+ if (union_dr)
+ pfree(union_dr);
+ datum_l = union_dl;
+ size_l = size_alpha;
+ *left++ = i;
+ v->spl_nleft++;
+ }
+ else
+ {
+ if (datum_r)
+ pfree(datum_r);
+ if (union_dl)
+ pfree(union_dl);
+ datum_r = union_dr;
+ size_r = size_beta;
+ *right++ = i;
+ v->spl_nright++;
+ }
}
- }
- if ( *(left-1) > *(right-1) ) {
- *right = FirstOffsetNumber;
- *(left-1) = InvalidOffsetNumber;
- } else {
- *left = FirstOffsetNumber;
- *(right-1) = InvalidOffsetNumber;
- }
+ if (*(left - 1) > *(right - 1))
+ {
+ *right = FirstOffsetNumber;
+ *(left - 1) = InvalidOffsetNumber;
+ }
+ else
+ {
+ *left = FirstOffsetNumber;
+ *(right - 1) = InvalidOffsetNumber;
+ }
- v->spl_ldatum = (char *)datum_l;
- v->spl_rdatum = (char *)datum_r;
+ v->spl_ldatum = (char *) datum_l;
+ v->spl_rdatum = (char *) datum_r;
#ifdef GIST_DEBUG
- elog(NOTICE, "--------ENDpicksplit %d %d",v->spl_nleft, v->spl_nright);
+ elog(NOTICE, "--------ENDpicksplit %d %d", v->spl_nleft, v->spl_nright);
#endif
- return v;
+ return v;
}
projects / postgresql.git / commitdiff