Skip to content

P
Postgres FD Implementation
Commit 6f2182fe authored by Tom Lane's avatar Tom Lane
Browse files
Options

contrib/intarray updates from Oleg Bartunov: 

it's reimplemented to use function interface version 1 and special
treating of degenerated signatures.
parent 88ba4018
Show whitespace changes
Inline Side-by-side
Showing with 263 additions and 138 deletions
contrib/intarray/_int.c
View file @ 6f2182fe
......@@ -41,13 +41,13 @@
#define SORT(x) \
do { \
if ( ARRNELEMS( x ) > 1 ) \
isort( (void*)ARRPTR( x ), ARRNELEMS( x ) ); \
isort( ARRPTR( x ), ARRNELEMS( x ) ); \
} while(0)
#define PREPAREARR(x) \
do { \
if ( ARRNELEMS( x ) > 1 ) \
if ( isort( (void*)ARRPTR( x ), ARRNELEMS( x ) ) ) \
if ( isort( ARRPTR( x ), ARRNELEMS( x ) ) ) \
x = _int_unique( x ); \
} while(0)
......@@ -126,7 +126,7 @@ typedef void (*formfloat) (ArrayType *, float *);
/*
** usefull function
*/
static bool isort(int *a, const int len);
static bool isort(int4 *a, const int len);
static ArrayType *new_intArrayType(int num);
static ArrayType *copy_intArrayType(ArrayType *a);
static ArrayType *resize_intArrayType(ArrayType *a, int num);
......@@ -152,48 +152,72 @@ static ArrayType *_int_common_union(bytea *entryvec,
/*
** GiST support methods
*/
bool g_int_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy);
GISTENTRY *g_int_compress(GISTENTRY *entry);
GISTENTRY *g_int_decompress(GISTENTRY *entry);
float *g_int_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
GIST_SPLITVEC *g_int_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
ArrayType *g_int_union(bytea *entryvec, int *sizep);
bool *g_int_same(ArrayType *b1, ArrayType *b2, bool *result);
PG_FUNCTION_INFO_V1( g_int_consistent );
PG_FUNCTION_INFO_V1( g_int_compress );
PG_FUNCTION_INFO_V1( g_int_decompress );
PG_FUNCTION_INFO_V1( g_int_penalty );
PG_FUNCTION_INFO_V1( g_int_picksplit );
PG_FUNCTION_INFO_V1( g_int_union );
PG_FUNCTION_INFO_V1( g_int_same );
Datum g_int_consistent(PG_FUNCTION_ARGS);
Datum g_int_compress(PG_FUNCTION_ARGS);
Datum g_int_decompress(PG_FUNCTION_ARGS);
Datum g_int_penalty(PG_FUNCTION_ARGS);
Datum g_int_picksplit(PG_FUNCTION_ARGS);
Datum g_int_union(PG_FUNCTION_ARGS);
Datum g_int_same(PG_FUNCTION_ARGS);
/*
** R-tree support functions
*/
bool inner_int_contains(ArrayType *a, ArrayType *b);
bool inner_int_overlap(ArrayType *a, ArrayType *b);
ArrayType *inner_int_union(ArrayType *a, ArrayType *b);
ArrayType *inner_int_inter(ArrayType *a, ArrayType *b);
bool _int_different(ArrayType *a, ArrayType *b);
bool _int_same(ArrayType *a, ArrayType *b);
bool _int_contains(ArrayType *a, ArrayType *b);
bool _int_contained(ArrayType *a, ArrayType *b);
bool _int_overlap(ArrayType *a, ArrayType *b);
ArrayType *_int_union(ArrayType *a, ArrayType *b);
ArrayType *_int_inter(ArrayType *a, ArrayType *b);
void rt__int_size(ArrayType *a, float *sz);
static bool inner_int_contains(ArrayType *a, ArrayType *b);
static bool inner_int_overlap(ArrayType *a, ArrayType *b);
static ArrayType *inner_int_union(ArrayType *a, ArrayType *b);
static ArrayType *inner_int_inter(ArrayType *a, ArrayType *b);
static void rt__int_size(ArrayType *a, float *sz);
PG_FUNCTION_INFO_V1( _int_different );
PG_FUNCTION_INFO_V1( _int_same );
PG_FUNCTION_INFO_V1( _int_contains );
PG_FUNCTION_INFO_V1( _int_contained );
PG_FUNCTION_INFO_V1( _int_overlap );
PG_FUNCTION_INFO_V1( _int_union );
PG_FUNCTION_INFO_V1( _int_inter );
Datum _int_different(PG_FUNCTION_ARGS);
Datum _int_same(PG_FUNCTION_ARGS);
Datum _int_contains(PG_FUNCTION_ARGS);
Datum _int_contained(PG_FUNCTION_ARGS);
Datum _int_overlap(PG_FUNCTION_ARGS);
Datum _int_union(PG_FUNCTION_ARGS);
Datum _int_inter(PG_FUNCTION_ARGS);
/*
** _intbig methods
*/
bool g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy);
GISTENTRY *g_intbig_compress(GISTENTRY *entry);
GISTENTRY *g_intbig_decompress(GISTENTRY *entry);
float *g_intbig_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
GIST_SPLITVEC *g_intbig_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
ArrayType *g_intbig_union(bytea *entryvec, int *sizep);
bool *g_intbig_same(ArrayType *a, ArrayType *b, bool *result);
PG_FUNCTION_INFO_V1( g_intbig_consistent );
PG_FUNCTION_INFO_V1( g_intbig_compress );
PG_FUNCTION_INFO_V1( g_intbig_decompress );
PG_FUNCTION_INFO_V1( g_intbig_penalty );
PG_FUNCTION_INFO_V1( g_intbig_picksplit );
PG_FUNCTION_INFO_V1( g_intbig_union );
PG_FUNCTION_INFO_V1( g_intbig_same );
Datum g_intbig_consistent(PG_FUNCTION_ARGS);
Datum g_intbig_compress(PG_FUNCTION_ARGS);
Datum g_intbig_decompress(PG_FUNCTION_ARGS);
Datum g_intbig_penalty(PG_FUNCTION_ARGS);
Datum g_intbig_picksplit(PG_FUNCTION_ARGS);
Datum g_intbig_union(PG_FUNCTION_ARGS);
Datum g_intbig_same(PG_FUNCTION_ARGS);
static bool _intbig_contains(ArrayType *a, ArrayType *b);
static bool _intbig_overlap(ArrayType *a, ArrayType *b);
static ArrayType *_intbig_union(ArrayType *a, ArrayType *b);
/*static ArrayType * _intbig_inter(ArrayType *a, ArrayType *b);*/
static ArrayType * _intbig_inter(ArrayType *a, ArrayType *b);
static void rt__intbig_size(ArrayType *a, float *sz);
static void gensign(BITVEC sign, int *a, int len);
......@@ -207,11 +231,11 @@ static void gensign(BITVEC sign, int *a, int len);
** the predicate x op query == FALSE, where op is the oper
** corresponding to strategy in the pg_amop table.
*/
bool
g_int_consistent(GISTENTRY *entry,
ArrayType *query,
StrategyNumber strategy)
{
Datum
g_int_consistent(PG_FUNCTION_ARGS) {
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
ArrayType *query = ( ArrayType * )PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
/* sort query for fast search, key is already sorted */
......@@ -239,21 +263,26 @@ g_int_consistent(GISTENTRY *entry,
default:
retval = FALSE;
}
return (retval);
PG_RETURN_BOOL(retval);
}
ArrayType *
g_int_union(bytea *entryvec, int *sizep)
Datum
g_int_union(PG_FUNCTION_ARGS)
{
return _int_common_union(entryvec, sizep, inner_int_union);
PG_RETURN_POINTER( _int_common_union(
(bytea *) PG_GETARG_POINTER(0),
(int *) PG_GETARG_POINTER(1),
inner_int_union
) );
}
/*
** GiST Compress and Decompress methods
*/
GISTENTRY *
g_int_compress(GISTENTRY *entry)
Datum
g_int_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
GISTENTRY *retval;
ArrayType *r;
int len;
......@@ -280,7 +309,7 @@ g_int_compress(GISTENTRY *entry)
gistentryinit(*retval, (Datum) 0, entry->rel, entry->page, entry->offset,
0, FALSE);
return (retval);
PG_RETURN_POINTER(retval);
}
if (entry->leafkey)
......@@ -320,12 +349,13 @@ g_int_compress(GISTENTRY *entry)
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
return (retval);
PG_RETURN_POINTER(retval);
}
GISTENTRY *
g_int_decompress(GISTENTRY *entry)
Datum
g_int_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
GISTENTRY *retval;
ArrayType *r;
int *dr,
......@@ -352,7 +382,7 @@ g_int_decompress(GISTENTRY *entry)
#ifdef GIST_DEBUG
elog(NOTICE, "DECOMP IN: NULL");
#endif
return (retval);
PG_RETURN_POINTER(retval);
}
......@@ -363,7 +393,7 @@ g_int_decompress(GISTENTRY *entry)
{ /* not comressed value */
/* sometimes strange bytesize */
gistentryinit(*entry, PointerGetDatum(in), entry->rel, entry->page, entry->offset, VARSIZE(in), FALSE);
return (entry);
PG_RETURN_POINTER(entry);
}
#ifdef GIST_DEBUG
......@@ -386,28 +416,35 @@ g_int_decompress(GISTENTRY *entry)
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
return (retval);
PG_RETURN_POINTER(retval);
}
/*
** The GiST Penalty method for _intments
*/
float *
g_int_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
Datum
g_int_penalty(PG_FUNCTION_ARGS)
{
return _int_common_penalty(origentry, newentry, result, inner_int_union, rt__int_size);
PG_RETURN_POINTER( _int_common_penalty(
(GISTENTRY *)PG_GETARG_POINTER(0),
(GISTENTRY *)PG_GETARG_POINTER(1),
(float *) PG_GETARG_POINTER(2),
inner_int_union, rt__int_size
) );
}
GIST_SPLITVEC *
g_int_picksplit(bytea *entryvec,
GIST_SPLITVEC *v)
Datum
g_int_picksplit(PG_FUNCTION_ARGS)
{
return _int_common_picksplit(entryvec, v,
PG_RETURN_POINTER( _int_common_picksplit(
(bytea *)PG_GETARG_POINTER(0),
(GIST_SPLITVEC *)PG_GETARG_POINTER(1),
inner_int_union,
inner_int_inter,
rt__int_size,
1e-8);
1e-8
) );
}
/*
......@@ -415,26 +452,38 @@ g_int_picksplit(bytea *entryvec,
*/
bool *
g_int_same(ArrayType *b1, ArrayType *b2, bool *result)
Datum
g_int_same(PG_FUNCTION_ARGS)
{
if (_int_same(b1, b2))
*result = TRUE;
else
*result = FALSE;
bool *result = (bool *)PG_GETARG_POINTER(2);
*result = DatumGetBool(
DirectFunctionCall2(
_int_same,
PointerGetDatum(PG_GETARG_POINTER(0)),
PointerGetDatum(PG_GETARG_POINTER(1))
)
);
return (result);
PG_RETURN_POINTER(result);
}
bool
_int_contained(ArrayType *a, ArrayType *b)
Datum
_int_contained(PG_FUNCTION_ARGS)
{
return (_int_contains(b, a));
PG_RETURN_BOOL( DatumGetBool(
DirectFunctionCall2(
_int_contains,
PointerGetDatum(PG_GETARG_POINTER(1)),
PointerGetDatum(PG_GETARG_POINTER(0))
)
));
}
bool
_int_contains(ArrayType *a, ArrayType *b)
Datum
_int_contains(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
bool res;
ArrayType *an,
*bn;
......@@ -451,10 +500,10 @@ _int_contains(ArrayType *a, ArrayType *b)
res = inner_int_contains(an, bn);
pfree(an);
pfree(bn);
return res;
PG_RETURN_BOOL( res );
}
bool
static bool
inner_int_contains(ArrayType *a, ArrayType *b)
{
int na,
......@@ -497,15 +546,23 @@ inner_int_contains(ArrayType *a, ArrayType *b)
* Operator class for R-tree indexing
*****************************************************************************/
bool
_int_different(ArrayType *a, ArrayType *b)
Datum
_int_different(PG_FUNCTION_ARGS)
{
return (!_int_same(a, b));
PG_RETURN_BOOL( ! DatumGetBool(
DirectFunctionCall2(
_int_same,
PointerGetDatum(PG_GETARG_POINTER(0)),
PointerGetDatum(PG_GETARG_POINTER(1))
)
));
}
bool
_int_same(ArrayType *a, ArrayType *b)
Datum
_int_same(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
int na,
nb;
int n;
......@@ -546,14 +603,16 @@ _int_same(ArrayType *a, ArrayType *b)
pfree(an);
pfree(bn);
return result;
PG_RETURN_BOOL(result);
}
/* _int_overlap -- does a overlap b?
*/
bool
_int_overlap(ArrayType *a, ArrayType *b)
Datum
_int_overlap(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
bool result;
ArrayType *an,
*bn;
......@@ -572,10 +631,10 @@ _int_overlap(ArrayType *a, ArrayType *b)
pfree(an);
pfree(bn);
return result;
PG_RETURN_BOOL( result );
}
bool
static bool
inner_int_overlap(ArrayType *a, ArrayType *b)
{
int na,
......@@ -609,9 +668,11 @@ inner_int_overlap(ArrayType *a, ArrayType *b)
return FALSE;
}
ArrayType *
_int_union(ArrayType *a, ArrayType *b)
Datum
_int_union(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
ArrayType *result;
ArrayType *an,
*bn;
......@@ -631,10 +692,10 @@ _int_union(ArrayType *a, ArrayType *b)
if (bn)
pfree(bn);
return result;
PG_RETURN_POINTER( result );
}
ArrayType *
static ArrayType *
inner_int_union(ArrayType *a, ArrayType *b)
{
ArrayType *r = NULL;
......@@ -691,15 +752,17 @@ inner_int_union(ArrayType *a, ArrayType *b)
}
ArrayType *
_int_inter(ArrayType *a, ArrayType *b)
Datum
_int_inter(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
ArrayType *result;
ArrayType *an,
*bn;
if (ARRISNULL(a) || ARRISNULL(b))
return new_intArrayType(0);
PG_RETURN_POINTER(new_intArrayType(0));
an = copy_intArrayType(a);
bn = copy_intArrayType(b);
......@@ -712,10 +775,10 @@ _int_inter(ArrayType *a, ArrayType *b)
pfree(an);
pfree(bn);
return result;
PG_RETURN_POINTER( result );
}
ArrayType *
static ArrayType *
inner_int_inter(ArrayType *a, ArrayType *b)
{
ArrayType *r;
......@@ -764,7 +827,7 @@ inner_int_inter(ArrayType *a, ArrayType *b)
return resize_intArrayType(r, dr - ARRPTR(r));
}
void
static void
rt__int_size(ArrayType *a, float *size)
{
if (ARRISNULL(a))
......@@ -782,11 +845,11 @@ rt__int_size(ArrayType *a, float *size)
/* len >= 2 */
static bool
isort(int *a, int len)
isort(int4 *a, int len)
{
int tmp,
int4 tmp,
index;
int *cur,
int4 *cur,
*end;
bool r = FALSE;
......@@ -1006,9 +1069,12 @@ _intbig_inter(ArrayType *a, ArrayType *b)
return r;
}
bool *
g_intbig_same(ArrayType *a, ArrayType *b, bool *result)
Datum
g_intbig_same(PG_FUNCTION_ARGS)
{
ArrayType *a = (ArrayType *)PG_GETARG_POINTER(0);
ArrayType *b = (ArrayType *)PG_GETARG_POINTER(1);
bool *result = (bool *)PG_GETARG_POINTER(2);
BITVECP da,
db;
int i;
......@@ -1016,7 +1082,7 @@ g_intbig_same(ArrayType *a, ArrayType *b, bool *result)
if (ARRISNULL(a) || ARRISNULL(b))
{
*result = (ARRISNULL(a) && ARRISNULL(b)) ? TRUE : FALSE;
return result;
PG_RETURN_POINTER( result );
}
da = SIGPTR(a);
......@@ -1026,28 +1092,46 @@ g_intbig_same(ArrayType *a, ArrayType *b, bool *result)
if (da[i] != db[i])
{
*result = FALSE;
return result;
PG_RETURN_POINTER( result );
}
);
*result = TRUE;
return result;
PG_RETURN_POINTER( result );
}
GISTENTRY *
g_intbig_compress(GISTENTRY *entry)
Datum
g_intbig_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
GISTENTRY *retval;
ArrayType *r,
*in;
bool maycompress = true;
int i;
if (DatumGetPointer(entry->key) != NULL)
in = (ArrayType *) PG_DETOAST_DATUM(entry->key);
else
in = NULL;
if (!entry->leafkey)
return entry;
if (!entry->leafkey) {
if ( ! ARRISNULL(in) ) {
LOOPBYTE(
if ( ( ((char*)ARRPTR(in))[i] & 0xff ) != 0xff ) {
maycompress = false;
break;
}
);
if ( maycompress ) {
retval = palloc(sizeof(GISTENTRY));
r = new_intArrayType(1);
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
PG_RETURN_POINTER( retval );
}
}
PG_RETURN_POINTER( entry );
}
retval = palloc(sizeof(GISTENTRY));
......@@ -1057,7 +1141,7 @@ g_intbig_compress(GISTENTRY *entry)
if (in != (ArrayType *) DatumGetPointer(entry->key))
pfree(in);
gistentryinit(*retval, (Datum) 0, entry->rel, entry->page, entry->offset, 0, FALSE);
return (retval);
PG_RETURN_POINTER (retval);
}
r = new_intArrayType(SIGLENINT);
......@@ -1065,60 +1149,101 @@ g_intbig_compress(GISTENTRY *entry)
ARRPTR(in),
ARRNELEMS(in));
LOOPBYTE(
if( ( ((char*)ARRPTR(in))[i] & 0xff ) != 0xff ) {
maycompress = false;
break;
}
);
if ( maycompress ) {
pfree(r);
r = new_intArrayType(1);
}
gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page, entry->offset, VARSIZE(r), FALSE);
if (in)
if (in != (ArrayType *) DatumGetPointer(entry->key))
if ( in != (ArrayType *) DatumGetPointer(entry->key))
pfree(in);
return (retval);
PG_RETURN_POINTER (retval);
}
GISTENTRY *
g_intbig_decompress(GISTENTRY *entry)
Datum
g_intbig_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
ArrayType *key;
if ( DatumGetPointer(entry->key) != NULL )
key = (ArrayType *) PG_DETOAST_DATUM(entry->key);
if (key != (ArrayType *) DatumGetPointer(entry->key))
else
key = NULL;
if ( key != (ArrayType *) DatumGetPointer(entry->key))
{
GISTENTRY *retval;
retval = palloc(sizeof(GISTENTRY));
gistentryinit(*retval, PointerGetDatum(key), entry->rel, entry->page, entry->offset, VARSIZE(key), FALSE);
return retval;
gistentryinit(*retval, PointerGetDatum(key), entry->rel, entry->page, entry->offset, (key) ? VARSIZE(key) : 0, FALSE);
PG_RETURN_POINTER( retval );
}
if ( ! ARRISNULL(key) )
if ( ARRNELEMS(key) == 1 ) {
GISTENTRY *retval;
ArrayType *newkey;
retval = palloc(sizeof(GISTENTRY));
newkey = new_intArrayType(SIGLENINT);
MemSet( (void*)ARRPTR(newkey), 0xff, SIGLEN );
gistentryinit(*retval, PointerGetDatum(newkey), entry->rel, entry->page, entry->offset, VARSIZE(newkey), FALSE);
PG_RETURN_POINTER( retval );
}
return entry;
PG_RETURN_POINTER( entry );
}
GIST_SPLITVEC *
g_intbig_picksplit(bytea *entryvec, GIST_SPLITVEC *v)
Datum
g_intbig_picksplit(PG_FUNCTION_ARGS)
{
return _int_common_picksplit(entryvec, v,
PG_RETURN_POINTER( _int_common_picksplit(
(bytea *)PG_GETARG_POINTER(0),
(GIST_SPLITVEC *)PG_GETARG_POINTER(1),
_intbig_union,
_intbig_inter,
rt__intbig_size,
1.0);
1.0
) );
}
ArrayType *
g_intbig_union(bytea *entryvec, int *sizep)
Datum
g_intbig_union(PG_FUNCTION_ARGS)
{
return _int_common_union(entryvec, sizep, _intbig_union);
PG_RETURN_POINTER( _int_common_union(
(bytea *) PG_GETARG_POINTER(0),
(int *) PG_GETARG_POINTER(1),
_intbig_union
) );
}
float *
g_intbig_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
Datum
g_intbig_penalty(PG_FUNCTION_ARGS)
{
_int_common_penalty(origentry, newentry, result, _intbig_union, rt__intbig_size);
return result;
PG_RETURN_POINTER( _int_common_penalty(
(GISTENTRY *)PG_GETARG_POINTER(0),
(GISTENTRY *)PG_GETARG_POINTER(1),
(float *) PG_GETARG_POINTER(2),
_intbig_union, rt__intbig_size
) );
}
bool
g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy)
{
Datum
g_intbig_consistent(PG_FUNCTION_ARGS) {
GISTENTRY *entry = (GISTENTRY *)PG_GETARG_POINTER(0);
ArrayType *query = ( ArrayType * )PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool retval;
ArrayType *q;
......@@ -1147,7 +1272,7 @@ g_intbig_consistent(GISTENTRY *entry, ArrayType *query, StrategyNumber strategy)
retval = FALSE;
}
pfree(q);
return (retval);
PG_RETURN_BOOL(retval);
}
/*****************************************************************
......@@ -1158,7 +1283,7 @@ 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 *
static ArrayType *
_int_common_union(bytea *entryvec, int *sizep, formarray unionf)
{
int numranges,
......@@ -1202,7 +1327,7 @@ _int_common_union(bytea *entryvec, int *sizep, formarray unionf)
* The GiST Penalty method for _intments *
*****************************************/
float *
static float *
_int_common_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result,
formarray unionf,
formfloat sizef)
......@@ -1232,7 +1357,7 @@ _int_common_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result,
** The GiST PickSplit method for _intments
** We use Guttman's poly time split algorithm
*/
GIST_SPLITVEC *
static GIST_SPLITVEC *
_int_common_picksplit(bytea *entryvec,
GIST_SPLITVEC *v,
formarray unionf,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment