From 339cd6b9b00451f1f7046d6b52500e2d2992a385 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 22 Mar 2001 15:24:12 +0000 Subject: [PATCH] Run pgindent on _int.c, for Tom Lane. I had skipped this file because of a complex macro that pgindent complained about. Hand-adjusted macro for pgindent run. --- contrib/intarray/_int.c | 1671 ++++++++++++++++++++++----------------- 1 file changed, 931 insertions(+), 740 deletions(-) diff --git a/contrib/intarray/_int.c b/contrib/intarray/_int.c index 352f5ce48f..f15d3ca112 100644 --- a/contrib/intarray/_int.c +++ b/contrib/intarray/_int.c @@ -6,7 +6,7 @@ /* #define GIST_DEBUG -#define GIST_QUERY_DEBUG +#define GIST_QUERY_DEBUG */ #include "postgres.h" @@ -23,11 +23,11 @@ #include "storage/bufpage.h" /* number ranges for compression */ -#define MAXNUMRANGE 100 +#define MAXNUMRANGE 100 -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define abs(a) ((a) < (0) ? -(a) : (a)) +#define max(a,b) ((a) > (b) ? (a) : (b)) +#define min(a,b) ((a) <= (b) ? (a) : (b)) +#define abs(a) ((a) < (0) ? -(a) : (a)) /* dimension of array */ #define NDIM 1 @@ -61,24 +61,25 @@ /* bigint defines */ #define BITBYTE 8 -#define SIGLENINT 64 /* >122 => key will toast, so very slow!!! */ -#define SIGLEN ( sizeof(int)*SIGLENINT ) +#define SIGLENINT 64 /* >122 => key will toast, so very slow!!! */ +#define SIGLEN ( sizeof(int)*SIGLENINT ) #define SIGLENBIT (SIGLEN*BITBYTE) typedef char BITVEC[SIGLEN]; -typedef char* BITVECP; +typedef char *BITVECP; + #define SIGPTR(x) ( (BITVECP) ARR_DATA_PTR(x) ) #define LOOPBYTE(a) \ - for(i=0;ipred), query); - break; - case RTSameStrategyNumber: - case RTContainsStrategyNumber: - retval = (bool)inner_int_contains((ArrayType *)(entry->pred), query); - break; - case RTContainedByStrategyNumber: - retval = (bool)inner_int_overlap((ArrayType *)(entry->pred), query); - break; - default: - retval = FALSE; - } - return(retval); + switch (strategy) + { + case RTOverlapStrategyNumber: + retval = (bool) inner_int_overlap((ArrayType *) (entry->pred), query); + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + retval = (bool) inner_int_contains((ArrayType *) (entry->pred), query); + break; + case RTContainedByStrategyNumber: + retval = (bool) inner_int_overlap((ArrayType *) (entry->pred), query); + break; + default: + retval = FALSE; + } + return (retval); } -ArrayType * +ArrayType * g_int_union(bytea *entryvec, int *sizep) { - return _int_common_union( entryvec, sizep, inner_int_union ); + return _int_common_union(entryvec, sizep, inner_int_union); } /* ** GiST Compress and Decompress methods */ -GISTENTRY * +GISTENTRY * g_int_compress(GISTENTRY *entry) { - GISTENTRY *retval; - ArrayType * r; - int len; - int *dr; - int i,min,cand; + GISTENTRY *retval; + ArrayType *r; + int len; + int *dr; + int i, + min, + cand; - retval = palloc(sizeof(GISTENTRY)); + retval = palloc(sizeof(GISTENTRY)); #ifdef PGSQL71 - if ( entry->pred ) - r = (ArrayType *)PG_DETOAST_DATUM_COPY( entry->pred ); - else + if (entry->pred) + r = (ArrayType *) PG_DETOAST_DATUM_COPY(entry->pred); + else r = NULL; #else - r = copy_intArrayType( (ArrayType *) entry->pred ); + r = copy_intArrayType((ArrayType *) entry->pred); #endif - if ( ARRISNULL( r ) ) { + if (ARRISNULL(r)) + { #ifdef GIST_DEBUG - elog(NOTICE,"COMP IN: NULL"); + elog(NOTICE, "COMP IN: NULL"); #endif - if ( r ) if ( (char*)r != (char*)entry->pred ) pfree(r); + if (r) + if ((char *) r != (char *) entry->pred) + pfree(r); - gistentryinit(*retval, (char *)NULL, entry->rel, entry->page, entry->offset, - 0, FALSE); - return( retval ); - } - - if ( entry->leafkey ) PREPAREARR( r ); - len = ARRNELEMS( r ); - -#ifdef GIST_DEBUG - elog(NOTICE, "COMP IN: %d leaf; %d rel; %d page; %d offset; %d bytes; %d elems", entry->leafkey, (int)entry->rel, (int)entry->page, (int)entry->offset, (int)entry->bytes, len); -#endif - - if ( len >= 2*MAXNUMRANGE ) { /*compress*/ - r = resize_intArrayType( r, 2*( len ) ); - - dr = ARRPTR( r ); - - for(i=len-1; i>=0;i--) - dr[2*i] = dr[2*i+1] = dr[i]; - - len *= 2; - cand = 1; - while( len > MAXNUMRANGE * 2 ) { - min = 0x7fffffff; - for( i=2; i (dr[i] - dr[i-1]) ) { - min = (dr[i] - dr[i-1]); - cand = i; - } - memmove( (void*)&dr[cand-1], (void*)&dr[cand+1], (len - cand - 1)*sizeof(int) ); - len -= 2; + gistentryinit(*retval, (char *) NULL, entry->rel, entry->page, entry->offset, + 0, FALSE); + return (retval); } - r = resize_intArrayType(r, len ); - } - gistentryinit(*retval, (char *)r, entry->rel, entry->page, entry->offset, VARSIZE( r ), FALSE); + if (entry->leafkey) + PREPAREARR(r); + len = ARRNELEMS(r); - return(retval); +#ifdef GIST_DEBUG + elog(NOTICE, "COMP IN: %d leaf; %d rel; %d page; %d offset; %d bytes; %d elems", entry->leafkey, (int) entry->rel, (int) entry->page, (int) entry->offset, (int) entry->bytes, len); +#endif + + if (len >= 2 * MAXNUMRANGE) + { /* compress */ + r = resize_intArrayType(r, 2 * (len)); + + dr = ARRPTR(r); + + for (i = len - 1; i >= 0; i--) + dr[2 * i] = dr[2 * i + 1] = dr[i]; + + len *= 2; + cand = 1; + while (len > MAXNUMRANGE * 2) + { + min = 0x7fffffff; + for (i = 2; i < len; i += 2) + if (min > (dr[i] - dr[i - 1])) + { + min = (dr[i] - dr[i - 1]); + cand = i; + } + memmove((void *) &dr[cand - 1], (void *) &dr[cand + 1], (len - cand - 1) * sizeof(int)); + len -= 2; + } + r = resize_intArrayType(r, len); + } + + gistentryinit(*retval, (char *) r, entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE); + + return (retval); } -GISTENTRY * +GISTENTRY * g_int_decompress(GISTENTRY *entry) { - GISTENTRY *retval; - ArrayType * r; - int *dr, lenr; - ArrayType * in; - int lenin; - int *din; - int i,j; + GISTENTRY *retval; + ArrayType *r; + int *dr, + lenr; + ArrayType *in; + int lenin; + int *din; + int i, + j; #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->bytes < ARR_OVERHEAD( NDIM ) || ARRISNULL( in ) ) { - retval = palloc(sizeof(GISTENTRY)); + if (entry->bytes < ARR_OVERHEAD(NDIM) || ARRISNULL(in)) + { + retval = palloc(sizeof(GISTENTRY)); -#ifdef PGSQL71 - if ( in ) if ( (char*)in != (char*)entry->pred ) pfree(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); + gistentryinit(*retval, (char *) NULL, entry->rel, entry->page, entry->offset, 0, FALSE); #ifdef GIST_DEBUG - elog(NOTICE,"DECOMP IN: NULL"); + elog(NOTICE, "DECOMP IN: NULL"); #endif - return( retval ); - } - + return (retval); + } - lenin = ARRNELEMS(in); - din = ARRPTR(in); - if ( lenin < 2*MAXNUMRANGE ) { /*not comressed value*/ - /* sometimes strange bytesize */ - gistentryinit(*entry, (char *)in, entry->rel, entry->page, entry->offset, VARSIZE( in ), FALSE); - return (entry); - } + lenin = ARRNELEMS(in); + din = ARRPTR(in); + + if (lenin < 2 * MAXNUMRANGE) + { /* not comressed value */ + /* sometimes strange bytesize */ + gistentryinit(*entry, (char *) in, entry->rel, entry->page, entry->offset, VARSIZE(in), FALSE); + return (entry); + } #ifdef GIST_DEBUG - elog(NOTICE, "DECOMP IN: %d leaf; %d rel; %d page; %d offset; %d bytes; %d elems", entry->leafkey, (int)entry->rel, (int)entry->page, (int)entry->offset, (int)entry->bytes, lenin); + elog(NOTICE, "DECOMP IN: %d leaf; %d rel; %d page; %d offset; %d bytes; %d elems", entry->leafkey, (int) entry->rel, (int) entry->page, (int) entry->offset, (int) entry->bytes, lenin); #endif - lenr = internal_size(din, lenin); + lenr = internal_size(din, lenin); - r = new_intArrayType( lenr ); - dr = ARRPTR( r ); + r = new_intArrayType(lenr); + dr = ARRPTR(r); - for(i=0;ipred ) pfree(in); +#ifdef PGSQL71 + if ((char *) in != (char *) entry->pred) + pfree(in); #endif - retval = palloc(sizeof(GISTENTRY)); + retval = palloc(sizeof(GISTENTRY)); - gistentryinit(*retval, (char *)r, entry->rel, entry->page, entry->offset, VARSIZE( r ), FALSE); + gistentryinit(*retval, (char *) r, entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE); - return(retval); + return (retval); } /* @@ -379,19 +407,19 @@ g_int_decompress(GISTENTRY *entry) float * g_int_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result) { - return _int_common_penalty( origentry, newentry, result, inner_int_union, rt__int_size); + return _int_common_penalty(origentry, newentry, result, inner_int_union, rt__int_size); } GIST_SPLITVEC * g_int_picksplit(bytea *entryvec, - GIST_SPLITVEC *v) + GIST_SPLITVEC *v) { - return _int_common_picksplit( entryvec, v, - inner_int_union, - inner_int_inter, - rt__int_size, - 1e-8); + return _int_common_picksplit(entryvec, v, + inner_int_union, + inner_int_inter, + rt__int_size, + 1e-8); } /* @@ -402,64 +430,79 @@ g_int_picksplit(bytea *entryvec, bool * g_int_same(ArrayType *b1, ArrayType *b2, bool *result) { - if (_int_same(b1, b2)) - *result = TRUE; - else *result = FALSE; + if (_int_same(b1, b2)) + *result = TRUE; + else + *result = FALSE; - return(result); + return (result); } bool _int_contained(ArrayType *a, ArrayType *b) { - return ( _int_contains(b, a) ); + return (_int_contains(b, a)); } bool -_int_contains ( ArrayType *a, ArrayType *b ) { - bool res; - ArrayType *an, *bn; +_int_contains(ArrayType *a, ArrayType *b) +{ + bool res; + ArrayType *an, + *bn; - if ( ARRISNULL( a ) || ARRISNULL( b ) ) return FALSE; + if (ARRISNULL(a) || ARRISNULL(b)) + return FALSE; - an = copy_intArrayType( a ); - bn = copy_intArrayType( b ); + an = copy_intArrayType(a); + bn = copy_intArrayType(b); PREPAREARR(an); PREPAREARR(bn); - res = inner_int_contains( an, bn ); - pfree( an ); pfree( bn ); + res = inner_int_contains(an, bn); + pfree(an); + pfree(bn); return res; } -bool -inner_int_contains ( ArrayType *a, ArrayType *b ) { - int na, nb; - int i,j, n; - int *da, *db; - - if ( ARRISNULL( a ) || ARRISNULL( b ) ) return FALSE; +bool +inner_int_contains(ArrayType *a, ArrayType *b) +{ + int na, + nb; + int i, + j, + n; + int *da, + *db; - na = ARRNELEMS( a ); - nb = ARRNELEMS( b ); - da = ARRPTR( a ); - db = ARRPTR( b ); + if (ARRISNULL(a) || ARRISNULL(b)) + return FALSE; + + na = ARRNELEMS(a); + nb = ARRNELEMS(b); + da = ARRPTR(a); + db = ARRPTR(b); #ifdef GIST_DEBUG - elog(NOTICE, "contains %d %d", na, nb); + elog(NOTICE, "contains %d %d", na, nb); #endif i = j = n = 0; - while( i 1 ) - r = _int_unique( r ); + } + + if (ARRNELEMS(r) > 1) + r = _int_unique(r); return r; } -ArrayType * -_int_inter ( ArrayType *a, ArrayType *b ) { - ArrayType *result; - ArrayType *an, *bn; - - if ( ARRISNULL( a ) || ARRISNULL( b ) ) return new_intArrayType(0); +ArrayType * +_int_inter(ArrayType *a, ArrayType *b) +{ + ArrayType *result; + ArrayType *an, + *bn; - an = copy_intArrayType( a ); - bn = copy_intArrayType( b ); + if (ARRISNULL(a) || ARRISNULL(b)) + return new_intArrayType(0); + + an = copy_intArrayType(a); + bn = copy_intArrayType(b); SORT(an); SORT(bn); - result = inner_int_inter( an, bn ); + result = inner_int_inter(an, bn); - pfree( an ); pfree( bn ); + pfree(an); + pfree(bn); return result; } -ArrayType * -inner_int_inter ( ArrayType *a, ArrayType *b ) { - ArrayType * r; - int na , nb ; - int *da, *db, *dr; - int i,j; +ArrayType * +inner_int_inter(ArrayType *a, ArrayType *b) +{ + ArrayType *r; + int na, + nb; + int *da, + *db, + *dr; + int i, + j; #ifdef GIST_DEBUG - elog(NOTICE, "inner_inter %d %d", ARRISNULL( a ), ARRISNULL( b ) ); + elog(NOTICE, "inner_inter %d %d", ARRISNULL(a), ARRISNULL(b)); #endif - if ( ARRISNULL( a ) || ARRISNULL( b ) ) return new_intArrayType(0); + if (ARRISNULL(a) || ARRISNULL(b)) + return new_intArrayType(0); + + na = ARRNELEMS(a); + nb = ARRNELEMS(b); + da = ARRPTR(a); + db = ARRPTR(b); + r = new_intArrayType(min(na, nb)); + dr = ARRPTR(r); - na = ARRNELEMS( a ); - nb = ARRNELEMS( b ); - da = ARRPTR( a ); - db = ARRPTR( b ); - r = new_intArrayType( min(na, nb) ); - dr = ARRPTR( r ); - i = j = 0; - while( i0 && *(dr-1) != db[j] ) ) + else if (da[i] == db[j]) + { + if (i + j == 0 || (i + j > 0 && *(dr - 1) != db[j])) *dr++ = db[j]; - i++; j++; - } else + i++; + j++; + } + else j++; - if ( (dr - ARRPTR(r)) == 0 ) { - pfree( r ); + if ((dr - ARRPTR(r)) == 0) + { + pfree(r); return new_intArrayType(0); - } else - return resize_intArrayType(r, dr - ARRPTR(r) ); + } + else + return resize_intArrayType(r, dr - ARRPTR(r)); } void rt__int_size(ArrayType *a, float *size) { - if ( ARRISNULL( a ) ) - *size = 0.0; - else - *size = (float)ARRNELEMS( a ); - - return; + if (ARRISNULL(a)) + *size = 0.0; + else + *size = (float) ARRNELEMS(a); + + return; } /***************************************************************************** - * Miscellaneous operators and functions + * Miscellaneous operators and functions *****************************************************************************/ /* len >= 2 */ -static bool -isort ( int *a, int len ) { - int tmp, index; - int *cur, *end; - bool r = FALSE; - end = a + len; - do { - index = 0; - cur = a + 1; - while( cur < end ) { - if( *(cur-1) > *cur ) { - tmp=*(cur-1); *(cur-1) = *cur; *cur=tmp; - index = 1; - } else if ( ! r && *(cur-1) == *cur ) +static bool +isort(int *a, int len) +{ + int tmp, + index; + int *cur, + *end; + bool r = FALSE; + + end = a + len; + do + { + index = 0; + cur = a + 1; + while (cur < end) + { + if (*(cur - 1) > *cur) + { + tmp = *(cur - 1); + *(cur - 1) = *cur; + *cur = tmp; + index = 1; + } + else if (!r && *(cur - 1) == *cur) r = TRUE; - cur++; - } - } while( index ); + cur++; + } + } while (index); return r; } -static ArrayType * -new_intArrayType( int num ) { - ArrayType * r; - int nbytes = ARR_OVERHEAD( NDIM ) + sizeof(int)*num; - - r = (ArrayType *) palloc( nbytes ); +static ArrayType * +new_intArrayType(int num) +{ + ArrayType *r; + int nbytes = ARR_OVERHEAD(NDIM) + sizeof(int) * num; + + r = (ArrayType *) palloc(nbytes); MemSet(r, 0, nbytes); r->size = nbytes; @@ -738,127 +838,156 @@ new_intArrayType( int num ) { #ifndef PGSQL71 SET_LO_FLAG(false, r); #endif - *( (int*)ARR_DIMS(r) ) = num; - *( (int*)ARR_LBOUND(r) ) = 1; - - return r; -} + *((int *) ARR_DIMS(r)) = num; + *((int *) ARR_LBOUND(r)) = 1; -static ArrayType * -resize_intArrayType( ArrayType * a, int num ) { - int nbytes = ARR_OVERHEAD( NDIM ) + sizeof(int)*num; + return r; +} - if ( num == ARRNELEMS(a) ) return a; +static ArrayType * +resize_intArrayType(ArrayType *a, int num) +{ + int nbytes = ARR_OVERHEAD(NDIM) + sizeof(int) * num; + + if (num == ARRNELEMS(a)) + return a; + + a = (ArrayType *) repalloc(a, nbytes); - a = (ArrayType *) repalloc( a, nbytes ); - a->size = nbytes; - *( (int*)ARR_DIMS(a) ) = num; + *((int *) ARR_DIMS(a)) = num; return a; } -static ArrayType * -copy_intArrayType( ArrayType * a ) { - ArrayType * r; - if ( ARRISNULL(a) ) return NULL; - r = new_intArrayType( ARRNELEMS(a) ); - memmove(r,a,VARSIZE(a)); +static ArrayType * +copy_intArrayType(ArrayType *a) +{ + ArrayType *r; + + if (ARRISNULL(a)) + return NULL; + r = new_intArrayType(ARRNELEMS(a)); + memmove(r, a, VARSIZE(a)); return r; } /* num for compressed key */ -static int -internal_size (int *a, int len ) { - int i,size=0; +static int +internal_size(int *a, int len) +{ + int i, + size = 0; - for(i=0;i 1 */ -static ArrayType * -_int_unique( ArrayType * r ) { - int *tmp, *dr, *data; - int num = ARRNELEMS(r); - data = tmp = dr = ARRPTR( r ); - while( tmp - data < num ) - if ( *tmp != *dr ) +static ArrayType * +_int_unique(ArrayType *r) +{ + int *tmp, + *dr, + *data; + int num = ARRNELEMS(r); + + data = tmp = dr = ARRPTR(r); + while (tmp - data < num) + if (*tmp != *dr) *(++dr) = *tmp++; - else - tmp++; - return resize_intArrayType(r, dr + 1 - ARRPTR(r) ); + else + tmp++; + return resize_intArrayType(r, dr + 1 - ARRPTR(r)); } /********************************************************************* ** intbig functions *********************************************************************/ -static void -gensign(BITVEC sign, int * a, int len) { - int i; - /* we assume that the sign vector is previously zeroed */ - for(i=0; ipred ) - 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; + if (ARRISNULL(query)) + return FALSE; - q = new_intArrayType( SIGLENINT ); - gensign( SIGPTR( q ), - ARRPTR( query ), - ARRNELEMS( query ) ); + 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); + 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); } /***************************************************************** @@ -1027,37 +1183,43 @@ g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy) ** 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; -#ifdef GIST_DEBUG - elog(NOTICE, "_int_common_union in"); -#endif - - numranges = (VARSIZE(entryvec) - VARHDRSZ)/sizeof(GISTENTRY); - tmp = (ArrayType *)(((GISTENTRY *)(VARDATA(entryvec)))[0]).pred; +ArrayType * +_int_common_union(bytea *entryvec, int *sizep, formarray unionf) +{ + int numranges, + i; + ArrayType *out = (ArrayType *) NULL; + ArrayType *tmp; - for (i = 1; i < numranges; i++) { - out = (*unionf)(tmp, (ArrayType *) - (((GISTENTRY *)(VARDATA(entryvec)))[i]).pred); - if (i > 1 && tmp) pfree(tmp); - tmp = out; - } +#ifdef GIST_DEBUG + elog(NOTICE, "_int_common_union in"); +#endif - *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); } @@ -1067,181 +1229,210 @@ _int_common_union(bytea *entryvec, int *sizep, formarray unionf) { float * _int_common_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result, - formarray unionf, - formfloat sizef) + formarray unionf, + formfloat sizef) { - Datum ud; - float tmp1, tmp2; - -#ifdef GIST_DEBUG - 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); + Datum ud; + float tmp1, + tmp2; #ifdef GIST_DEBUG - elog(NOTICE, "--penalty\t%g", *result); + 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); + +#ifdef GIST_DEBUG + 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; + + 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++; + } } - - /* 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; }