Cleanup vectors of GISTENTRY and eliminate problem with 64-bit strict-aligned
boxes. Change interface to user-defined GiST support methods union and picksplit. Now instead of bytea struct it used special GistEntryVector structure.
This commit is contained in:
parent
8d9a28eeef
commit
f2c064afcb
|
@ -22,14 +22,14 @@ btree_decompress(PG_FUNCTION_ARGS)
|
||||||
** The GiST PickSplit method
|
** The GiST PickSplit method
|
||||||
*/
|
*/
|
||||||
extern GIST_SPLITVEC *
|
extern GIST_SPLITVEC *
|
||||||
btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
|
btree_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
|
||||||
{
|
{
|
||||||
OffsetNumber i;
|
OffsetNumber i;
|
||||||
RIX *array;
|
RIX *array;
|
||||||
OffsetNumber maxoff;
|
OffsetNumber maxoff;
|
||||||
int nbytes;
|
int nbytes;
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
|
maxoff = entryvec->n - 1;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
@ -43,7 +43,7 @@ btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v, BINARY_UNION bu, CMPFUNC cmp)
|
||||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
array[i].index = i;
|
array[i].index = i;
|
||||||
array[i].r = (char *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
|
array[i].r = (char *) DatumGetPointer((entryvec->vector[i].key));
|
||||||
}
|
}
|
||||||
qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
|
qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
|
||||||
sizeof(RIX), cmp);
|
sizeof(RIX), cmp);
|
||||||
|
|
|
@ -21,5 +21,5 @@ typedef struct rix
|
||||||
** Common btree-function (for all ops)
|
** Common btree-function (for all ops)
|
||||||
*/
|
*/
|
||||||
|
|
||||||
extern GIST_SPLITVEC *btree_picksplit(bytea *entryvec, GIST_SPLITVEC *v,
|
extern GIST_SPLITVEC *btree_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
||||||
BINARY_UNION bu, CMPFUNC cmp);
|
BINARY_UNION bu, CMPFUNC cmp);
|
||||||
|
|
|
@ -120,7 +120,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gint2_union(bytea, internal)
|
CREATE FUNCTION gint2_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -140,7 +140,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gint2_consistent (internal, int2, int2),
|
FUNCTION 1 gint2_consistent (internal, int2, int2),
|
||||||
FUNCTION 2 gint2_union (bytea, internal),
|
FUNCTION 2 gint2_union (internal, internal),
|
||||||
FUNCTION 3 gint2_compress (internal),
|
FUNCTION 3 gint2_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gint2_penalty (internal, internal, internal),
|
FUNCTION 5 gint2_penalty (internal, internal, internal),
|
||||||
|
@ -176,7 +176,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gint4_union(bytea, internal)
|
CREATE FUNCTION gint4_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -196,7 +196,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gint4_consistent (internal, int4, int2),
|
FUNCTION 1 gint4_consistent (internal, int4, int2),
|
||||||
FUNCTION 2 gint4_union (bytea, internal),
|
FUNCTION 2 gint4_union (internal, internal),
|
||||||
FUNCTION 3 gint4_compress (internal),
|
FUNCTION 3 gint4_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gint4_penalty (internal, internal, internal),
|
FUNCTION 5 gint4_penalty (internal, internal, internal),
|
||||||
|
@ -232,7 +232,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gint8_union(bytea, internal)
|
CREATE FUNCTION gint8_union(internal, internal)
|
||||||
RETURNS int8key
|
RETURNS int8key
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -252,7 +252,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gint8_consistent (internal, int8, int2),
|
FUNCTION 1 gint8_consistent (internal, int8, int2),
|
||||||
FUNCTION 2 gint8_union (bytea, internal),
|
FUNCTION 2 gint8_union (internal, internal),
|
||||||
FUNCTION 3 gint8_compress (internal),
|
FUNCTION 3 gint8_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gint8_penalty (internal, internal, internal),
|
FUNCTION 5 gint8_penalty (internal, internal, internal),
|
||||||
|
@ -289,7 +289,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gfloat4_union(bytea, internal)
|
CREATE FUNCTION gfloat4_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -309,7 +309,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gfloat4_consistent (internal, float4, int2),
|
FUNCTION 1 gfloat4_consistent (internal, float4, int2),
|
||||||
FUNCTION 2 gfloat4_union (bytea, internal),
|
FUNCTION 2 gfloat4_union (internal, internal),
|
||||||
FUNCTION 3 gfloat4_compress (internal),
|
FUNCTION 3 gfloat4_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gfloat4_penalty (internal, internal, internal),
|
FUNCTION 5 gfloat4_penalty (internal, internal, internal),
|
||||||
|
@ -348,7 +348,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gfloat8_union(bytea, internal)
|
CREATE FUNCTION gfloat8_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -368,7 +368,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gfloat8_consistent (internal, float8, int2),
|
FUNCTION 1 gfloat8_consistent (internal, float8, int2),
|
||||||
FUNCTION 2 gfloat8_union (bytea, internal),
|
FUNCTION 2 gfloat8_union (internal, internal),
|
||||||
FUNCTION 3 gfloat8_compress (internal),
|
FUNCTION 3 gfloat8_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gfloat8_penalty (internal, internal, internal),
|
FUNCTION 5 gfloat8_penalty (internal, internal, internal),
|
||||||
|
@ -422,7 +422,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gts_union(bytea, internal)
|
CREATE FUNCTION gts_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -442,7 +442,7 @@ AS
|
||||||
OPERATOR 4 >= ,
|
OPERATOR 4 >= ,
|
||||||
OPERATOR 5 > ,
|
OPERATOR 5 > ,
|
||||||
FUNCTION 1 gts_consistent (internal, timestamp, int2),
|
FUNCTION 1 gts_consistent (internal, timestamp, int2),
|
||||||
FUNCTION 2 gts_union (bytea, internal),
|
FUNCTION 2 gts_union (internal, internal),
|
||||||
FUNCTION 3 gts_compress (internal),
|
FUNCTION 3 gts_compress (internal),
|
||||||
FUNCTION 4 btree_decompress (internal),
|
FUNCTION 4 btree_decompress (internal),
|
||||||
FUNCTION 5 gts_penalty (internal, internal, internal),
|
FUNCTION 5 gts_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -138,22 +138,22 @@ g__BTREE_GIST_TYPE2___consistent(PG_FUNCTION_ARGS)
|
||||||
Datum
|
Datum
|
||||||
g__BTREE_GIST_TYPE2___union(PG_FUNCTION_ARGS)
|
g__BTREE_GIST_TYPE2___union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int i,
|
int i,
|
||||||
numranges;
|
numranges;
|
||||||
__BTREE_GIST_TYPE__KEY *cur,
|
__BTREE_GIST_TYPE__KEY *cur,
|
||||||
*out = palloc(sizeof(__BTREE_GIST_TYPE__KEY));
|
*out = palloc(sizeof(__BTREE_GIST_TYPE__KEY));
|
||||||
|
|
||||||
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
numranges = entryvec->n;
|
||||||
*(int *) PG_GETARG_POINTER(1) = sizeof(__BTREE_GIST_TYPE__KEY);
|
*(int *) PG_GETARG_POINTER(1) = sizeof(__BTREE_GIST_TYPE__KEY);
|
||||||
|
|
||||||
cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
|
cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((entryvec->vector[0].key));
|
||||||
out->lower = cur->lower;
|
out->lower = cur->lower;
|
||||||
out->upper = cur->upper;
|
out->upper = cur->upper;
|
||||||
|
|
||||||
for (i = 1; i < numranges; i++)
|
for (i = 1; i < numranges; i++)
|
||||||
{
|
{
|
||||||
cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
|
cur = (__BTREE_GIST_TYPE__KEY *) DatumGetPointer((entryvec->vector[i].key));
|
||||||
if (out->lower > cur->lower)
|
if (out->lower > cur->lower)
|
||||||
out->lower = cur->lower;
|
out->lower = cur->lower;
|
||||||
if (out->upper < cur->upper)
|
if (out->upper < cur->upper)
|
||||||
|
@ -180,7 +180,7 @@ Datum
|
||||||
g__BTREE_GIST_TYPE2___picksplit(PG_FUNCTION_ARGS)
|
g__BTREE_GIST_TYPE2___picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
PG_RETURN_POINTER(btree_picksplit(
|
PG_RETURN_POINTER(btree_picksplit(
|
||||||
(bytea *) PG_GETARG_POINTER(0),
|
(GistEntryVector *) PG_GETARG_POINTER(0),
|
||||||
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
|
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
|
||||||
g__BTREE_GIST_TYPE2___binary_union,
|
g__BTREE_GIST_TYPE2___binary_union,
|
||||||
__BTREE_GIST_TYPE2__key_cmp
|
__BTREE_GIST_TYPE2__key_cmp
|
||||||
|
|
|
@ -146,22 +146,22 @@ gts_consistent(PG_FUNCTION_ARGS)
|
||||||
Datum
|
Datum
|
||||||
gts_union(PG_FUNCTION_ARGS)
|
gts_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int i,
|
int i,
|
||||||
numranges;
|
numranges;
|
||||||
TSKEY *cur,
|
TSKEY *cur,
|
||||||
*out = palloc(sizeof(TSKEY));
|
*out = palloc(sizeof(TSKEY));
|
||||||
|
|
||||||
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
numranges = entryvec->n;
|
||||||
*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
|
*(int *) PG_GETARG_POINTER(1) = sizeof(TSKEY);
|
||||||
|
|
||||||
cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0].key));
|
cur = (TSKEY *) DatumGetPointer((entryvec->vector[0].key));
|
||||||
out->lower = cur->lower;
|
out->lower = cur->lower;
|
||||||
out->upper = cur->upper;
|
out->upper = cur->upper;
|
||||||
|
|
||||||
for (i = 1; i < numranges; i++)
|
for (i = 1; i < numranges; i++)
|
||||||
{
|
{
|
||||||
cur = (TSKEY *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i].key));
|
cur = (TSKEY *) DatumGetPointer((entryvec->vector[i].key));
|
||||||
if (TSGT(&out->lower, &cur->lower))
|
if (TSGT(&out->lower, &cur->lower))
|
||||||
out->lower = cur->lower;
|
out->lower = cur->lower;
|
||||||
if (TSLT(&out->upper, &cur->upper))
|
if (TSLT(&out->upper, &cur->upper))
|
||||||
|
@ -204,7 +204,7 @@ Datum
|
||||||
gts_picksplit(PG_FUNCTION_ARGS)
|
gts_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
PG_RETURN_POINTER(btree_picksplit(
|
PG_RETURN_POINTER(btree_picksplit(
|
||||||
(bytea *) PG_GETARG_POINTER(0),
|
(GistEntryVector *) PG_GETARG_POINTER(0),
|
||||||
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
|
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
|
||||||
gts_binary_union,
|
gts_binary_union,
|
||||||
tskey_cmp
|
tskey_cmp
|
||||||
|
|
|
@ -46,10 +46,10 @@ bool g_cube_consistent(GISTENTRY *entry, NDBOX * query, StrategyNumber strategy
|
||||||
GISTENTRY *g_cube_compress(GISTENTRY *entry);
|
GISTENTRY *g_cube_compress(GISTENTRY *entry);
|
||||||
GISTENTRY *g_cube_decompress(GISTENTRY *entry);
|
GISTENTRY *g_cube_decompress(GISTENTRY *entry);
|
||||||
float *g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
|
float *g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
|
||||||
GIST_SPLITVEC *g_cube_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
|
GIST_SPLITVEC *g_cube_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v);
|
||||||
bool g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
|
bool g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
|
||||||
bool g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
|
bool g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
|
||||||
NDBOX *g_cube_union(bytea *entryvec, int *sizep);
|
NDBOX *g_cube_union(GistEntryVector *entryvec, int *sizep);
|
||||||
NDBOX *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep);
|
NDBOX *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep);
|
||||||
bool *g_cube_same(NDBOX * b1, NDBOX * b2, bool *result);
|
bool *g_cube_same(NDBOX * b1, NDBOX * b2, bool *result);
|
||||||
|
|
||||||
|
@ -211,28 +211,26 @@ g_cube_consistent(GISTENTRY *entry,
|
||||||
** returns the minimal bounding box that encloses all the entries in entryvec
|
** returns the minimal bounding box that encloses all the entries in entryvec
|
||||||
*/
|
*/
|
||||||
NDBOX *
|
NDBOX *
|
||||||
g_cube_union(bytea *entryvec, int *sizep)
|
g_cube_union(GistEntryVector *entryvec, int *sizep)
|
||||||
{
|
{
|
||||||
int numranges,
|
int i;
|
||||||
i;
|
|
||||||
NDBOX *out = (NDBOX *) NULL;
|
NDBOX *out = (NDBOX *) NULL;
|
||||||
NDBOX *tmp;
|
NDBOX *tmp;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* fprintf(stderr, "union\n");
|
* fprintf(stderr, "union\n");
|
||||||
*/
|
*/
|
||||||
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
tmp = (NDBOX *) DatumGetPointer(entryvec->vector[0].key);
|
||||||
tmp = (NDBOX *) DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[0]).key);
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* sizep = sizeof(NDBOX); -- NDBOX has variable size
|
* sizep = sizeof(NDBOX); -- NDBOX has variable size
|
||||||
*/
|
*/
|
||||||
*sizep = tmp->size;
|
*sizep = tmp->size;
|
||||||
|
|
||||||
for (i = 1; i < numranges; i++)
|
for (i = 1; i < entryvec->n; i++)
|
||||||
{
|
{
|
||||||
out = g_cube_binary_union(tmp, (NDBOX *)
|
out = g_cube_binary_union(tmp, (NDBOX *)
|
||||||
DatumGetPointer((((GISTENTRY *) (VARDATA(entryvec)))[i]).key),
|
DatumGetPointer(entryvec->vector[i].key),
|
||||||
sizep);
|
sizep);
|
||||||
if (i > 1)
|
if (i > 1)
|
||||||
pfree(tmp);
|
pfree(tmp);
|
||||||
|
@ -289,7 +287,7 @@ g_cube_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
|
||||||
** We use Guttman's poly time split algorithm
|
** We use Guttman's poly time split algorithm
|
||||||
*/
|
*/
|
||||||
GIST_SPLITVEC *
|
GIST_SPLITVEC *
|
||||||
g_cube_picksplit(bytea *entryvec,
|
g_cube_picksplit(GistEntryVector *entryvec,
|
||||||
GIST_SPLITVEC *v)
|
GIST_SPLITVEC *v)
|
||||||
{
|
{
|
||||||
OffsetNumber i,
|
OffsetNumber i,
|
||||||
|
@ -321,7 +319,7 @@ g_cube_picksplit(bytea *entryvec,
|
||||||
/*
|
/*
|
||||||
* fprintf(stderr, "picksplit\n");
|
* fprintf(stderr, "picksplit\n");
|
||||||
*/
|
*/
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
@ -331,10 +329,10 @@ g_cube_picksplit(bytea *entryvec,
|
||||||
|
|
||||||
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
datum_alpha = (NDBOX *) DatumGetPointer(((GISTENTRY *) (VARDATA(entryvec)))[i].key);
|
datum_alpha = (NDBOX *) DatumGetPointer(entryvec->vector[i].key);
|
||||||
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
||||||
{
|
{
|
||||||
datum_beta = (NDBOX *) DatumGetPointer(((GISTENTRY *) (VARDATA(entryvec)))[j].key);
|
datum_beta = (NDBOX *) DatumGetPointer(entryvec->vector[j].key);
|
||||||
|
|
||||||
/* compute the wasted space by unioning these guys */
|
/* compute the wasted space by unioning these guys */
|
||||||
/* size_waste = size_union - size_inter; */
|
/* size_waste = size_union - size_inter; */
|
||||||
|
@ -369,10 +367,10 @@ g_cube_picksplit(bytea *entryvec,
|
||||||
right = v->spl_right;
|
right = v->spl_right;
|
||||||
v->spl_nright = 0;
|
v->spl_nright = 0;
|
||||||
|
|
||||||
datum_alpha = (NDBOX *) DatumGetPointer(((GISTENTRY *) (VARDATA(entryvec)))[seed_1].key);
|
datum_alpha = (NDBOX *) DatumGetPointer(entryvec->vector[seed_1].key);
|
||||||
datum_l = cube_union(datum_alpha, datum_alpha);
|
datum_l = cube_union(datum_alpha, datum_alpha);
|
||||||
rt_cube_size(datum_l, &size_l);
|
rt_cube_size(datum_l, &size_l);
|
||||||
datum_beta = (NDBOX *) DatumGetPointer(((GISTENTRY *) (VARDATA(entryvec)))[seed_2].key);
|
datum_beta = (NDBOX *) DatumGetPointer(entryvec->vector[seed_2].key);
|
||||||
datum_r = cube_union(datum_beta, datum_beta);
|
datum_r = cube_union(datum_beta, datum_beta);
|
||||||
rt_cube_size(datum_r, &size_r);
|
rt_cube_size(datum_r, &size_r);
|
||||||
|
|
||||||
|
@ -411,7 +409,7 @@ g_cube_picksplit(bytea *entryvec,
|
||||||
}
|
}
|
||||||
|
|
||||||
/* okay, which page needs least enlargement? */
|
/* okay, which page needs least enlargement? */
|
||||||
datum_alpha = (NDBOX *) DatumGetPointer(((GISTENTRY *) (VARDATA(entryvec)))[i].key);
|
datum_alpha = (NDBOX *) DatumGetPointer(entryvec->vector[i].key);
|
||||||
union_dl = cube_union(datum_l, datum_alpha);
|
union_dl = cube_union(datum_l, datum_alpha);
|
||||||
union_dr = cube_union(datum_r, datum_alpha);
|
union_dr = cube_union(datum_r, datum_alpha);
|
||||||
rt_cube_size(union_dl, &size_alpha);
|
rt_cube_size(union_dl, &size_alpha);
|
||||||
|
|
|
@ -324,7 +324,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE OR REPLACE FUNCTION g_cube_union(bytea, internal)
|
CREATE OR REPLACE FUNCTION g_cube_union(internal, internal)
|
||||||
RETURNS cube
|
RETURNS cube
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -357,7 +357,7 @@ CREATE OPERATOR CLASS gist_cube_ops
|
||||||
OPERATOR 7 @ ,
|
OPERATOR 7 @ ,
|
||||||
OPERATOR 8 ~ ,
|
OPERATOR 8 ~ ,
|
||||||
FUNCTION 1 g_cube_consistent (internal, cube, int4),
|
FUNCTION 1 g_cube_consistent (internal, cube, int4),
|
||||||
FUNCTION 2 g_cube_union (bytea, internal),
|
FUNCTION 2 g_cube_union (internal, internal),
|
||||||
FUNCTION 3 g_cube_compress (internal),
|
FUNCTION 3 g_cube_compress (internal),
|
||||||
FUNCTION 4 g_cube_decompress (internal),
|
FUNCTION 4 g_cube_decompress (internal),
|
||||||
FUNCTION 5 g_cube_penalty (internal, internal, internal),
|
FUNCTION 5 g_cube_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -327,7 +327,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION g_int_union(bytea, internal)
|
CREATE FUNCTION g_int_union(internal, internal)
|
||||||
RETURNS _int4
|
RETURNS _int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -348,7 +348,7 @@ DEFAULT FOR TYPE _int4 USING gist AS
|
||||||
OPERATOR 8 ~,
|
OPERATOR 8 ~,
|
||||||
OPERATOR 20 @@ (_int4, query_int),
|
OPERATOR 20 @@ (_int4, query_int),
|
||||||
FUNCTION 1 g_int_consistent (internal, _int4, int4),
|
FUNCTION 1 g_int_consistent (internal, _int4, int4),
|
||||||
FUNCTION 2 g_int_union (bytea, internal),
|
FUNCTION 2 g_int_union (internal, internal),
|
||||||
FUNCTION 3 g_int_compress (internal),
|
FUNCTION 3 g_int_compress (internal),
|
||||||
FUNCTION 4 g_int_decompress (internal),
|
FUNCTION 4 g_int_decompress (internal),
|
||||||
FUNCTION 5 g_int_penalty (internal, internal, internal),
|
FUNCTION 5 g_int_penalty (internal, internal, internal),
|
||||||
|
@ -402,7 +402,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION g_intbig_union(bytea, internal)
|
CREATE FUNCTION g_intbig_union(internal, internal)
|
||||||
RETURNS _int4
|
RETURNS _int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -423,7 +423,7 @@ AS
|
||||||
OPERATOR 8 ~ RECHECK,
|
OPERATOR 8 ~ RECHECK,
|
||||||
OPERATOR 20 @@ (_int4, query_int) RECHECK,
|
OPERATOR 20 @@ (_int4, query_int) RECHECK,
|
||||||
FUNCTION 1 g_intbig_consistent (internal, internal, int4),
|
FUNCTION 1 g_intbig_consistent (internal, internal, int4),
|
||||||
FUNCTION 2 g_intbig_union (bytea, internal),
|
FUNCTION 2 g_intbig_union (internal, internal),
|
||||||
FUNCTION 3 g_intbig_compress (internal),
|
FUNCTION 3 g_intbig_compress (internal),
|
||||||
FUNCTION 4 g_intbig_decompress (internal),
|
FUNCTION 4 g_intbig_decompress (internal),
|
||||||
FUNCTION 5 g_intbig_penalty (internal, internal, internal),
|
FUNCTION 5 g_intbig_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
#include "_int.h"
|
#include "_int.h"
|
||||||
|
|
||||||
#define GETENTRY(vec,pos) ((ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((ArrayType *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
|
|
||||||
/*
|
/*
|
||||||
** GiST support methods
|
** GiST support methods
|
||||||
|
@ -87,21 +87,20 @@ g_int_consistent(PG_FUNCTION_ARGS)
|
||||||
Datum
|
Datum
|
||||||
g_int_union(PG_FUNCTION_ARGS)
|
g_int_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
int4 i,
|
int4 i;
|
||||||
len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
|
||||||
ArrayType *res;
|
ArrayType *res;
|
||||||
int totlen = 0,
|
int totlen = 0,
|
||||||
*ptr;
|
*ptr;
|
||||||
|
|
||||||
for (i = 0; i < len; i++)
|
for (i = 0; i < entryvec->n; i++)
|
||||||
totlen += ARRNELEMS(GETENTRY(entryvec, i));
|
totlen += ARRNELEMS(GETENTRY(entryvec, i));
|
||||||
|
|
||||||
res = new_intArrayType(totlen);
|
res = new_intArrayType(totlen);
|
||||||
ptr = ARRPTR(res);
|
ptr = ARRPTR(res);
|
||||||
|
|
||||||
for (i = 0; i < len; i++)
|
for (i = 0; i < entryvec->n; i++)
|
||||||
{
|
{
|
||||||
memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));
|
memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));
|
||||||
ptr += ARRNELEMS(GETENTRY(entryvec, i));
|
ptr += ARRNELEMS(GETENTRY(entryvec, i));
|
||||||
|
@ -318,7 +317,7 @@ comparecost(const void *a, const void *b)
|
||||||
Datum
|
Datum
|
||||||
g_int_picksplit(PG_FUNCTION_ARGS)
|
g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber i,
|
OffsetNumber i,
|
||||||
j;
|
j;
|
||||||
|
@ -348,10 +347,10 @@ g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
SPLITCOST *costvector;
|
SPLITCOST *costvector;
|
||||||
|
|
||||||
#ifdef GIST_DEBUG
|
#ifdef GIST_DEBUG
|
||||||
elog(DEBUG3, "--------picksplit %d", (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY));
|
elog(DEBUG3, "--------picksplit %d", entryvec->n);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
@ -360,10 +359,10 @@ g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
waste = 0.0;
|
waste = 0.0;
|
||||||
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
datum_alpha = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
datum_alpha = GETENTRY(entryvec,i);
|
||||||
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
||||||
{
|
{
|
||||||
datum_beta = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[j].key);
|
datum_beta = GETENTRY(entryvec,j);
|
||||||
|
|
||||||
/* compute the wasted space by unioning these guys */
|
/* compute the wasted space by unioning these guys */
|
||||||
/* size_waste = size_union - size_inter; */
|
/* size_waste = size_union - size_inter; */
|
||||||
|
@ -403,10 +402,10 @@ g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
seed_2 = 2;
|
seed_2 = 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
datum_alpha = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_1].key);
|
datum_alpha = GETENTRY(entryvec,seed_1);
|
||||||
datum_l = copy_intArrayType(datum_alpha);
|
datum_l = copy_intArrayType(datum_alpha);
|
||||||
rt__int_size(datum_l, &size_l);
|
rt__int_size(datum_l, &size_l);
|
||||||
datum_beta = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_2].key);
|
datum_beta = GETENTRY(entryvec,seed_2);
|
||||||
datum_r = copy_intArrayType(datum_beta);
|
datum_r = copy_intArrayType(datum_beta);
|
||||||
rt__int_size(datum_r, &size_r);
|
rt__int_size(datum_r, &size_r);
|
||||||
|
|
||||||
|
@ -419,7 +418,7 @@ g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
costvector[i - 1].pos = i;
|
costvector[i - 1].pos = i;
|
||||||
datum_alpha = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
datum_alpha = GETENTRY(entryvec,i);
|
||||||
union_d = inner_int_union(datum_l, datum_alpha);
|
union_d = inner_int_union(datum_l, datum_alpha);
|
||||||
rt__int_size(union_d, &size_alpha);
|
rt__int_size(union_d, &size_alpha);
|
||||||
pfree(union_d);
|
pfree(union_d);
|
||||||
|
@ -467,7 +466,7 @@ g_int_picksplit(PG_FUNCTION_ARGS)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* okay, which page needs least enlargement? */
|
/* okay, which page needs least enlargement? */
|
||||||
datum_alpha = (ArrayType *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
datum_alpha = GETENTRY(entryvec,i);
|
||||||
union_dl = inner_int_union(datum_l, datum_alpha);
|
union_dl = inner_int_union(datum_l, datum_alpha);
|
||||||
union_dr = inner_int_union(datum_r, datum_alpha);
|
union_dr = inner_int_union(datum_r, datum_alpha);
|
||||||
rt__int_size(union_dl, &size_alpha);
|
rt__int_size(union_dl, &size_alpha);
|
||||||
|
|
|
@ -1,6 +1,6 @@
|
||||||
#include "_int.h"
|
#include "_int.h"
|
||||||
|
|
||||||
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
/*
|
/*
|
||||||
** _intbig methods
|
** _intbig methods
|
||||||
*/
|
*/
|
||||||
|
@ -231,16 +231,15 @@ unionkey(BITVECP sbase, GISTTYPE * add)
|
||||||
|
|
||||||
Datum
|
Datum
|
||||||
g_intbig_union(PG_FUNCTION_ARGS) {
|
g_intbig_union(PG_FUNCTION_ARGS) {
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
BITVEC base;
|
BITVEC base;
|
||||||
int4 len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
int4 i, len;
|
||||||
int4 i;
|
|
||||||
int4 flag = 0;
|
int4 flag = 0;
|
||||||
GISTTYPE *result;
|
GISTTYPE *result;
|
||||||
|
|
||||||
MemSet((void *) base, 0, sizeof(BITVEC));
|
MemSet((void *) base, 0, sizeof(BITVEC));
|
||||||
for (i = 0; i < len; i++) {
|
for (i = 0; i < entryvec->n; i++) {
|
||||||
if (unionkey(base, GETENTRY(entryvec, i))) {
|
if (unionkey(base, GETENTRY(entryvec, i))) {
|
||||||
flag = ALLISTRUE;
|
flag = ALLISTRUE;
|
||||||
break;
|
break;
|
||||||
|
@ -283,7 +282,7 @@ comparecost(const void *a, const void *b) {
|
||||||
|
|
||||||
Datum
|
Datum
|
||||||
g_intbig_picksplit(PG_FUNCTION_ARGS) {
|
g_intbig_picksplit(PG_FUNCTION_ARGS) {
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber k,
|
OffsetNumber k,
|
||||||
j;
|
j;
|
||||||
|
@ -306,7 +305,7 @@ g_intbig_picksplit(PG_FUNCTION_ARGS) {
|
||||||
GISTTYPE *_k,
|
GISTTYPE *_k,
|
||||||
*_j;
|
*_j;
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
|
|
@ -29,7 +29,7 @@ Datum _ltree_picksplit(PG_FUNCTION_ARGS);
|
||||||
PG_FUNCTION_INFO_V1(_ltree_consistent);
|
PG_FUNCTION_INFO_V1(_ltree_consistent);
|
||||||
Datum _ltree_consistent(PG_FUNCTION_ARGS);
|
Datum _ltree_consistent(PG_FUNCTION_ARGS);
|
||||||
|
|
||||||
#define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
#define NEXTVAL(x) ( (ltree*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
|
#define NEXTVAL(x) ( (ltree*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
|
||||||
#define SUMBIT(val) ( \
|
#define SUMBIT(val) ( \
|
||||||
GETBITBYTE(val,0) + \
|
GETBITBYTE(val,0) + \
|
||||||
|
@ -172,16 +172,15 @@ unionkey(BITVECP sbase, ltree_gist * add)
|
||||||
Datum
|
Datum
|
||||||
_ltree_union(PG_FUNCTION_ARGS)
|
_ltree_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
ABITVEC base;
|
ABITVEC base;
|
||||||
int4 len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
int4 i,len;
|
||||||
int4 i;
|
|
||||||
int4 flag = 0;
|
int4 flag = 0;
|
||||||
ltree_gist *result;
|
ltree_gist *result;
|
||||||
|
|
||||||
MemSet((void *) base, 0, sizeof(ABITVEC));
|
MemSet((void *) base, 0, sizeof(ABITVEC));
|
||||||
for (i = 0; i < len; i++)
|
for (i = 0; i < entryvec->n; i++)
|
||||||
{
|
{
|
||||||
if (unionkey(base, GETENTRY(entryvec, i)))
|
if (unionkey(base, GETENTRY(entryvec, i)))
|
||||||
{
|
{
|
||||||
|
@ -264,7 +263,7 @@ comparecost(const void *a, const void *b)
|
||||||
Datum
|
Datum
|
||||||
_ltree_picksplit(PG_FUNCTION_ARGS)
|
_ltree_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber k,
|
OffsetNumber k,
|
||||||
j;
|
j;
|
||||||
|
@ -287,7 +286,7 @@ _ltree_picksplit(PG_FUNCTION_ARGS)
|
||||||
ltree_gist *_k,
|
ltree_gist *_k,
|
||||||
*_j;
|
*_j;
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
|
|
@ -499,7 +499,7 @@ CREATE FUNCTION ltree_penalty(internal,internal,internal)
|
||||||
RETURNS internal as 'MODULE_PATHNAME' language 'C' with(isstrict);
|
RETURNS internal as 'MODULE_PATHNAME' language 'C' with(isstrict);
|
||||||
CREATE FUNCTION ltree_picksplit(internal, internal)
|
CREATE FUNCTION ltree_picksplit(internal, internal)
|
||||||
RETURNS internal as 'MODULE_PATHNAME' language 'C';
|
RETURNS internal as 'MODULE_PATHNAME' language 'C';
|
||||||
CREATE FUNCTION ltree_union(bytea, internal)
|
CREATE FUNCTION ltree_union(internal, internal)
|
||||||
RETURNS int4 as 'MODULE_PATHNAME' language 'C';
|
RETURNS int4 as 'MODULE_PATHNAME' language 'C';
|
||||||
CREATE FUNCTION ltree_same(internal, internal, internal)
|
CREATE FUNCTION ltree_same(internal, internal, internal)
|
||||||
RETURNS internal as 'MODULE_PATHNAME' language 'C';
|
RETURNS internal as 'MODULE_PATHNAME' language 'C';
|
||||||
|
@ -520,7 +520,7 @@ CREATE OPERATOR CLASS gist_ltree_ops
|
||||||
OPERATOR 16 ? (ltree, _lquery) ,
|
OPERATOR 16 ? (ltree, _lquery) ,
|
||||||
OPERATOR 17 ? (_lquery, ltree) ,
|
OPERATOR 17 ? (_lquery, ltree) ,
|
||||||
FUNCTION 1 ltree_consistent (internal, internal, int2),
|
FUNCTION 1 ltree_consistent (internal, internal, int2),
|
||||||
FUNCTION 2 ltree_union (bytea, internal),
|
FUNCTION 2 ltree_union (internal, internal),
|
||||||
FUNCTION 3 ltree_compress (internal),
|
FUNCTION 3 ltree_compress (internal),
|
||||||
FUNCTION 4 ltree_decompress (internal),
|
FUNCTION 4 ltree_decompress (internal),
|
||||||
FUNCTION 5 ltree_penalty (internal, internal, internal),
|
FUNCTION 5 ltree_penalty (internal, internal, internal),
|
||||||
|
@ -825,7 +825,7 @@ CREATE FUNCTION _ltree_picksplit(internal, internal)
|
||||||
RETURNS internal
|
RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
CREATE FUNCTION _ltree_union(bytea, internal)
|
CREATE FUNCTION _ltree_union(internal, internal)
|
||||||
RETURNS int4
|
RETURNS int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -845,7 +845,7 @@ CREATE OPERATOR CLASS gist__ltree_ops
|
||||||
OPERATOR 16 ? (_ltree, _lquery) RECHECK ,
|
OPERATOR 16 ? (_ltree, _lquery) RECHECK ,
|
||||||
OPERATOR 17 ? (_lquery, _ltree) RECHECK ,
|
OPERATOR 17 ? (_lquery, _ltree) RECHECK ,
|
||||||
FUNCTION 1 _ltree_consistent (internal, internal, int2),
|
FUNCTION 1 _ltree_consistent (internal, internal, int2),
|
||||||
FUNCTION 2 _ltree_union (bytea, internal),
|
FUNCTION 2 _ltree_union (internal, internal),
|
||||||
FUNCTION 3 _ltree_compress (internal),
|
FUNCTION 3 _ltree_compress (internal),
|
||||||
FUNCTION 4 ltree_decompress (internal),
|
FUNCTION 4 ltree_decompress (internal),
|
||||||
FUNCTION 5 _ltree_penalty (internal, internal, internal),
|
FUNCTION 5 _ltree_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -58,7 +58,7 @@ PG_FUNCTION_INFO_V1(ltree_consistent);
|
||||||
Datum ltree_consistent(PG_FUNCTION_ARGS);
|
Datum ltree_consistent(PG_FUNCTION_ARGS);
|
||||||
|
|
||||||
#define ISEQ(a,b) ( (a)->numlevel == (b)->numlevel && ltree_compare(a,b)==0 )
|
#define ISEQ(a,b) ( (a)->numlevel == (b)->numlevel && ltree_compare(a,b)==0 )
|
||||||
#define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
|
|
||||||
Datum
|
Datum
|
||||||
ltree_compress(PG_FUNCTION_ARGS)
|
ltree_compress(PG_FUNCTION_ARGS)
|
||||||
|
@ -166,10 +166,9 @@ hashing(BITVECP sign, ltree * t)
|
||||||
Datum
|
Datum
|
||||||
ltree_union(PG_FUNCTION_ARGS)
|
ltree_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
BITVEC base;
|
BITVEC base;
|
||||||
int4 len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
|
||||||
int4 i,
|
int4 i,
|
||||||
j;
|
j;
|
||||||
ltree_gist *result,
|
ltree_gist *result,
|
||||||
|
@ -181,7 +180,7 @@ ltree_union(PG_FUNCTION_ARGS)
|
||||||
bool isleqr;
|
bool isleqr;
|
||||||
|
|
||||||
MemSet((void *) base, 0, sizeof(BITVEC));
|
MemSet((void *) base, 0, sizeof(BITVEC));
|
||||||
for (j = 0; j < len; j++)
|
for (j = 0; j < entryvec->n; j++)
|
||||||
{
|
{
|
||||||
cur = GETENTRY(entryvec, j);
|
cur = GETENTRY(entryvec, j);
|
||||||
if (LTG_ISONENODE(cur))
|
if (LTG_ISONENODE(cur))
|
||||||
|
@ -285,7 +284,7 @@ treekey_cmp(const void *a, const void *b)
|
||||||
Datum
|
Datum
|
||||||
ltree_picksplit(PG_FUNCTION_ARGS)
|
ltree_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber j;
|
OffsetNumber j;
|
||||||
int4 i;
|
int4 i;
|
||||||
|
@ -307,7 +306,7 @@ ltree_picksplit(PG_FUNCTION_ARGS)
|
||||||
|
|
||||||
memset((void *) ls, 0, sizeof(BITVEC));
|
memset((void *) ls, 0, sizeof(BITVEC));
|
||||||
memset((void *) rs, 0, sizeof(BITVEC));
|
memset((void *) rs, 0, sizeof(BITVEC));
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
|
maxoff = entryvec->n - 1;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
|
|
@ -7,7 +7,7 @@
|
||||||
*
|
*
|
||||||
*
|
*
|
||||||
* IDENTIFICATION
|
* IDENTIFICATION
|
||||||
* $PostgreSQL: pgsql/contrib/rtree_gist/rtree_gist.c,v 1.8 2003/11/29 19:51:35 pgsql Exp $
|
* $PostgreSQL: pgsql/contrib/rtree_gist/rtree_gist.c,v 1.9 2004/03/30 15:45:33 teodor Exp $
|
||||||
*
|
*
|
||||||
*-------------------------------------------------------------------------
|
*-------------------------------------------------------------------------
|
||||||
*/
|
*/
|
||||||
|
@ -98,21 +98,21 @@ gbox_consistent(PG_FUNCTION_ARGS)
|
||||||
Datum
|
Datum
|
||||||
gbox_union(PG_FUNCTION_ARGS)
|
gbox_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *sizep = (int *) PG_GETARG_POINTER(1);
|
int *sizep = (int *) PG_GETARG_POINTER(1);
|
||||||
int numranges,
|
int numranges,
|
||||||
i;
|
i;
|
||||||
BOX *cur,
|
BOX *cur,
|
||||||
*pageunion;
|
*pageunion;
|
||||||
|
|
||||||
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
numranges = entryvec->n;
|
||||||
pageunion = (BOX *) palloc(sizeof(BOX));
|
pageunion = (BOX *) palloc(sizeof(BOX));
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[0].key);
|
cur = DatumGetBoxP(entryvec->vector[0].key);
|
||||||
memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
|
memcpy((void *) pageunion, (void *) cur, sizeof(BOX));
|
||||||
|
|
||||||
for (i = 1; i < numranges; i++)
|
for (i = 1; i < numranges; i++)
|
||||||
{
|
{
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
cur = DatumGetBoxP(entryvec->vector[i].key);
|
||||||
if (pageunion->high.x < cur->high.x)
|
if (pageunion->high.x < cur->high.x)
|
||||||
pageunion->high.x = cur->high.x;
|
pageunion->high.x = cur->high.x;
|
||||||
if (pageunion->low.x > cur->low.x)
|
if (pageunion->low.x > cur->low.x)
|
||||||
|
@ -186,7 +186,7 @@ compare_KB(const void *a, const void *b)
|
||||||
Datum
|
Datum
|
||||||
gbox_picksplit(PG_FUNCTION_ARGS)
|
gbox_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber i;
|
OffsetNumber i;
|
||||||
OffsetNumber *listL,
|
OffsetNumber *listL,
|
||||||
|
@ -209,15 +209,15 @@ gbox_picksplit(PG_FUNCTION_ARGS)
|
||||||
int nbytes;
|
int nbytes;
|
||||||
|
|
||||||
posL = posR = posB = posT = 0;
|
posL = posR = posB = posT = 0;
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 1;
|
maxoff = entryvec->n - 1;
|
||||||
|
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[FirstOffsetNumber].key);
|
cur = DatumGetBoxP(entryvec->vector[FirstOffsetNumber].key);
|
||||||
memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
|
memcpy((void *) &pageunion, (void *) cur, sizeof(BOX));
|
||||||
|
|
||||||
/* find MBR */
|
/* find MBR */
|
||||||
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i))
|
for (i = OffsetNumberNext(FirstOffsetNumber); i <= maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
cur = DatumGetBoxP(entryvec->vector[i].key);
|
||||||
if (allisequal == true && (
|
if (allisequal == true && (
|
||||||
pageunion.high.x != cur->high.x ||
|
pageunion.high.x != cur->high.x ||
|
||||||
pageunion.high.y != cur->high.y ||
|
pageunion.high.y != cur->high.y ||
|
||||||
|
@ -243,7 +243,7 @@ gbox_picksplit(PG_FUNCTION_ARGS)
|
||||||
unionR = (BOX *) palloc(sizeof(BOX));
|
unionR = (BOX *) palloc(sizeof(BOX));
|
||||||
if (allisequal)
|
if (allisequal)
|
||||||
{
|
{
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[OffsetNumberNext(FirstOffsetNumber)].key);
|
cur = DatumGetBoxP(entryvec->vector[OffsetNumberNext(FirstOffsetNumber)].key);
|
||||||
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
|
if (memcmp((void *) cur, (void *) &pageunion, sizeof(BOX)) == 0)
|
||||||
{
|
{
|
||||||
v->spl_left = listL;
|
v->spl_left = listL;
|
||||||
|
@ -292,7 +292,7 @@ gbox_picksplit(PG_FUNCTION_ARGS)
|
||||||
|
|
||||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
cur = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
cur = DatumGetBoxP(entryvec->vector[i].key);
|
||||||
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
|
if (cur->low.x - pageunion.low.x < pageunion.high.x - cur->high.x)
|
||||||
ADDLIST(listL, unionL, posL, i);
|
ADDLIST(listL, unionL, posL, i);
|
||||||
else
|
else
|
||||||
|
@ -311,7 +311,7 @@ gbox_picksplit(PG_FUNCTION_ARGS)
|
||||||
posL = posR = posB = posT = 0;
|
posL = posR = posB = posT = 0;
|
||||||
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
arr[i - 1].key = DatumGetBoxP(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
arr[i - 1].key = DatumGetBoxP(entryvec->vector[i].key);
|
||||||
arr[i - 1].pos = i;
|
arr[i - 1].pos = i;
|
||||||
}
|
}
|
||||||
qsort(arr, maxoff, sizeof(KBsort), compare_KB);
|
qsort(arr, maxoff, sizeof(KBsort), compare_KB);
|
||||||
|
|
|
@ -34,7 +34,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gbox_union(bytea, internal)
|
CREATE FUNCTION gbox_union(internal, internal)
|
||||||
RETURNS box
|
RETURNS box
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -57,7 +57,7 @@ AS
|
||||||
OPERATOR 7 ~ ,
|
OPERATOR 7 ~ ,
|
||||||
OPERATOR 8 @ ,
|
OPERATOR 8 @ ,
|
||||||
FUNCTION 1 gbox_consistent (internal, box, int4),
|
FUNCTION 1 gbox_consistent (internal, box, int4),
|
||||||
FUNCTION 2 gbox_union (bytea, internal),
|
FUNCTION 2 gbox_union (internal, internal),
|
||||||
FUNCTION 3 gbox_compress (internal),
|
FUNCTION 3 gbox_compress (internal),
|
||||||
FUNCTION 4 rtree_decompress (internal),
|
FUNCTION 4 rtree_decompress (internal),
|
||||||
FUNCTION 5 gbox_penalty (internal, internal, internal),
|
FUNCTION 5 gbox_penalty (internal, internal, internal),
|
||||||
|
@ -96,7 +96,7 @@ AS
|
||||||
OPERATOR 7 ~ RECHECK,
|
OPERATOR 7 ~ RECHECK,
|
||||||
OPERATOR 8 @ RECHECK,
|
OPERATOR 8 @ RECHECK,
|
||||||
FUNCTION 1 gpoly_consistent (internal, polygon, int4),
|
FUNCTION 1 gpoly_consistent (internal, polygon, int4),
|
||||||
FUNCTION 2 gbox_union (bytea, internal),
|
FUNCTION 2 gbox_union (internal, internal),
|
||||||
FUNCTION 3 gpoly_compress (internal),
|
FUNCTION 3 gpoly_compress (internal),
|
||||||
FUNCTION 4 rtree_decompress (internal),
|
FUNCTION 4 rtree_decompress (internal),
|
||||||
FUNCTION 5 gbox_penalty (internal, internal, internal),
|
FUNCTION 5 gbox_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -48,10 +48,10 @@ bool gseg_consistent(GISTENTRY *entry, SEG * query, StrategyNumber strategy);
|
||||||
GISTENTRY *gseg_compress(GISTENTRY *entry);
|
GISTENTRY *gseg_compress(GISTENTRY *entry);
|
||||||
GISTENTRY *gseg_decompress(GISTENTRY *entry);
|
GISTENTRY *gseg_decompress(GISTENTRY *entry);
|
||||||
float *gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
|
float *gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
|
||||||
GIST_SPLITVEC *gseg_picksplit(bytea *entryvec, GIST_SPLITVEC *v);
|
GIST_SPLITVEC *gseg_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v);
|
||||||
bool gseg_leaf_consistent(SEG * key, SEG * query, StrategyNumber strategy);
|
bool gseg_leaf_consistent(SEG * key, SEG * query, StrategyNumber strategy);
|
||||||
bool gseg_internal_consistent(SEG * key, SEG * query, StrategyNumber strategy);
|
bool gseg_internal_consistent(SEG * key, SEG * query, StrategyNumber strategy);
|
||||||
SEG *gseg_union(bytea *entryvec, int *sizep);
|
SEG *gseg_union(GistEntryVector *entryvec, int *sizep);
|
||||||
SEG *gseg_binary_union(SEG * r1, SEG * r2, int *sizep);
|
SEG *gseg_binary_union(SEG * r1, SEG * r2, int *sizep);
|
||||||
bool *gseg_same(SEG * b1, SEG * b2, bool *result);
|
bool *gseg_same(SEG * b1, SEG * b2, bool *result);
|
||||||
|
|
||||||
|
@ -222,7 +222,7 @@ gseg_consistent(GISTENTRY *entry,
|
||||||
** returns the minimal bounding seg that encloses all the entries in entryvec
|
** returns the minimal bounding seg that encloses all the entries in entryvec
|
||||||
*/
|
*/
|
||||||
SEG *
|
SEG *
|
||||||
gseg_union(bytea *entryvec, int *sizep)
|
gseg_union(GistEntryVector *entryvec, int *sizep)
|
||||||
{
|
{
|
||||||
int numranges,
|
int numranges,
|
||||||
i;
|
i;
|
||||||
|
@ -233,14 +233,14 @@ gseg_union(bytea *entryvec, int *sizep)
|
||||||
fprintf(stderr, "union\n");
|
fprintf(stderr, "union\n");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
numranges = entryvec->n;
|
||||||
tmp = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[0].key);
|
tmp = (SEG *) DatumGetPointer(entryvec->vector[0].key);
|
||||||
*sizep = sizeof(SEG);
|
*sizep = sizeof(SEG);
|
||||||
|
|
||||||
for (i = 1; i < numranges; i++)
|
for (i = 1; i < numranges; i++)
|
||||||
{
|
{
|
||||||
out = gseg_binary_union(tmp, (SEG *)
|
out = gseg_binary_union(tmp, (SEG *)
|
||||||
DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key),
|
DatumGetPointer(entryvec->vector[i].key),
|
||||||
sizep);
|
sizep);
|
||||||
if (i > 1)
|
if (i > 1)
|
||||||
pfree(tmp);
|
pfree(tmp);
|
||||||
|
@ -299,7 +299,7 @@ gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result)
|
||||||
** We use Guttman's poly time split algorithm
|
** We use Guttman's poly time split algorithm
|
||||||
*/
|
*/
|
||||||
GIST_SPLITVEC *
|
GIST_SPLITVEC *
|
||||||
gseg_picksplit(bytea *entryvec,
|
gseg_picksplit(GistEntryVector *entryvec,
|
||||||
GIST_SPLITVEC *v)
|
GIST_SPLITVEC *v)
|
||||||
{
|
{
|
||||||
OffsetNumber i,
|
OffsetNumber i,
|
||||||
|
@ -332,7 +332,7 @@ gseg_picksplit(bytea *entryvec,
|
||||||
fprintf(stderr, "picksplit\n");
|
fprintf(stderr, "picksplit\n");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
@ -342,10 +342,10 @@ gseg_picksplit(bytea *entryvec,
|
||||||
|
|
||||||
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
||||||
{
|
{
|
||||||
datum_alpha = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
datum_alpha = (SEG *) DatumGetPointer(entryvec->vector[i].key);
|
||||||
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
||||||
{
|
{
|
||||||
datum_beta = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[j].key);
|
datum_beta = (SEG *) DatumGetPointer(entryvec->vector[j].key);
|
||||||
|
|
||||||
/* compute the wasted space by unioning these guys */
|
/* compute the wasted space by unioning these guys */
|
||||||
/* size_waste = size_union - size_inter; */
|
/* size_waste = size_union - size_inter; */
|
||||||
|
@ -380,10 +380,10 @@ gseg_picksplit(bytea *entryvec,
|
||||||
right = v->spl_right;
|
right = v->spl_right;
|
||||||
v->spl_nright = 0;
|
v->spl_nright = 0;
|
||||||
|
|
||||||
datum_alpha = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_1].key);
|
datum_alpha = (SEG *) DatumGetPointer(entryvec->vector[seed_1].key);
|
||||||
datum_l = seg_union(datum_alpha, datum_alpha);
|
datum_l = seg_union(datum_alpha, datum_alpha);
|
||||||
rt_seg_size(datum_l, &size_l);
|
rt_seg_size(datum_l, &size_l);
|
||||||
datum_beta = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[seed_2].key);
|
datum_beta = (SEG *) DatumGetPointer(entryvec->vector[seed_2].key);
|
||||||
datum_r = seg_union(datum_beta, datum_beta);
|
datum_r = seg_union(datum_beta, datum_beta);
|
||||||
rt_seg_size(datum_r, &size_r);
|
rt_seg_size(datum_r, &size_r);
|
||||||
|
|
||||||
|
@ -422,7 +422,7 @@ gseg_picksplit(bytea *entryvec,
|
||||||
}
|
}
|
||||||
|
|
||||||
/* okay, which page needs least enlargement? */
|
/* okay, which page needs least enlargement? */
|
||||||
datum_alpha = (SEG *) DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key);
|
datum_alpha = (SEG *) DatumGetPointer(entryvec->vector[i].key);
|
||||||
union_dl = seg_union(datum_l, datum_alpha);
|
union_dl = seg_union(datum_l, datum_alpha);
|
||||||
union_dr = seg_union(datum_r, datum_alpha);
|
union_dr = seg_union(datum_r, datum_alpha);
|
||||||
rt_seg_size(union_dl, &size_alpha);
|
rt_seg_size(union_dl, &size_alpha);
|
||||||
|
|
|
@ -328,7 +328,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gseg_union(bytea, internal)
|
CREATE FUNCTION gseg_union(internal, internal)
|
||||||
RETURNS seg
|
RETURNS seg
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -362,7 +362,7 @@ AS
|
||||||
OPERATOR 7 @ ,
|
OPERATOR 7 @ ,
|
||||||
OPERATOR 8 ~ ,
|
OPERATOR 8 ~ ,
|
||||||
FUNCTION 1 gseg_consistent (internal, seg, int4),
|
FUNCTION 1 gseg_consistent (internal, seg, int4),
|
||||||
FUNCTION 2 gseg_union (bytea, internal),
|
FUNCTION 2 gseg_union (internal, internal),
|
||||||
FUNCTION 3 gseg_compress (internal),
|
FUNCTION 3 gseg_compress (internal),
|
||||||
FUNCTION 4 gseg_decompress (internal),
|
FUNCTION 4 gseg_decompress (internal),
|
||||||
FUNCTION 5 gseg_penalty (internal, internal, internal),
|
FUNCTION 5 gseg_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -42,7 +42,7 @@ Datum gtxtidx_penalty(PG_FUNCTION_ARGS);
|
||||||
PG_FUNCTION_INFO_V1(gtxtidx_picksplit);
|
PG_FUNCTION_INFO_V1(gtxtidx_picksplit);
|
||||||
Datum gtxtidx_picksplit(PG_FUNCTION_ARGS);
|
Datum gtxtidx_picksplit(PG_FUNCTION_ARGS);
|
||||||
|
|
||||||
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
#define SUMBIT(val) ( \
|
#define SUMBIT(val) ( \
|
||||||
GETBITBYTE(val,0) + \
|
GETBITBYTE(val,0) + \
|
||||||
GETBITBYTE(val,1) + \
|
GETBITBYTE(val,1) + \
|
||||||
|
@ -326,16 +326,15 @@ unionkey(BITVECP sbase, GISTTYPE * add)
|
||||||
Datum
|
Datum
|
||||||
gtxtidx_union(PG_FUNCTION_ARGS)
|
gtxtidx_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
BITVEC base;
|
BITVEC base;
|
||||||
int4 len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
int4 i,len;
|
||||||
int4 i;
|
|
||||||
int4 flag = 0;
|
int4 flag = 0;
|
||||||
GISTTYPE *result;
|
GISTTYPE *result;
|
||||||
|
|
||||||
MemSet((void *) base, 0, sizeof(BITVEC));
|
MemSet((void *) base, 0, sizeof(BITVEC));
|
||||||
for (i = 0; i < len; i++)
|
for (i = 0; i < entryvec->n; i++)
|
||||||
{
|
{
|
||||||
if (unionkey(base, GETENTRY(entryvec, i)))
|
if (unionkey(base, GETENTRY(entryvec, i)))
|
||||||
{
|
{
|
||||||
|
@ -513,7 +512,7 @@ comparecost(const void *a, const void *b)
|
||||||
Datum
|
Datum
|
||||||
gtxtidx_picksplit(PG_FUNCTION_ARGS)
|
gtxtidx_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber k,
|
OffsetNumber k,
|
||||||
j;
|
j;
|
||||||
|
@ -544,7 +543,7 @@ gtxtidx_picksplit(PG_FUNCTION_ARGS)
|
||||||
char valtmp;
|
char valtmp;
|
||||||
SPLITCOST *costvector;
|
SPLITCOST *costvector;
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
|
|
@ -192,7 +192,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gtxtidx_union(bytea, internal)
|
CREATE FUNCTION gtxtidx_union(internal, internal)
|
||||||
RETURNS _int4
|
RETURNS _int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -209,7 +209,7 @@ AS
|
||||||
OPERATOR 1 @@ (txtidx, query_txt) RECHECK ,
|
OPERATOR 1 @@ (txtidx, query_txt) RECHECK ,
|
||||||
OPERATOR 2 ## (txtidx, mquery_txt) RECHECK ,
|
OPERATOR 2 ## (txtidx, mquery_txt) RECHECK ,
|
||||||
FUNCTION 1 gtxtidx_consistent (gtxtidx, internal, int4),
|
FUNCTION 1 gtxtidx_consistent (gtxtidx, internal, int4),
|
||||||
FUNCTION 2 gtxtidx_union (bytea, internal),
|
FUNCTION 2 gtxtidx_union (internal, internal),
|
||||||
FUNCTION 3 gtxtidx_compress (internal),
|
FUNCTION 3 gtxtidx_compress (internal),
|
||||||
FUNCTION 4 gtxtidx_decompress (internal),
|
FUNCTION 4 gtxtidx_decompress (internal),
|
||||||
FUNCTION 5 gtxtidx_penalty (internal, internal, internal),
|
FUNCTION 5 gtxtidx_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -42,7 +42,7 @@ Datum gtsvector_penalty(PG_FUNCTION_ARGS);
|
||||||
PG_FUNCTION_INFO_V1(gtsvector_picksplit);
|
PG_FUNCTION_INFO_V1(gtsvector_picksplit);
|
||||||
Datum gtsvector_picksplit(PG_FUNCTION_ARGS);
|
Datum gtsvector_picksplit(PG_FUNCTION_ARGS);
|
||||||
|
|
||||||
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer(((GISTENTRY *) VARDATA(vec))[(pos)].key))
|
#define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer((vec)->vector[(pos)].key))
|
||||||
#define SUMBIT(val) ( \
|
#define SUMBIT(val) ( \
|
||||||
GETBITBYTE(val,0) + \
|
GETBITBYTE(val,0) + \
|
||||||
GETBITBYTE(val,1) + \
|
GETBITBYTE(val,1) + \
|
||||||
|
@ -326,16 +326,15 @@ unionkey(BITVECP sbase, GISTTYPE * add)
|
||||||
Datum
|
Datum
|
||||||
gtsvector_union(PG_FUNCTION_ARGS)
|
gtsvector_union(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
int *size = (int *) PG_GETARG_POINTER(1);
|
int *size = (int *) PG_GETARG_POINTER(1);
|
||||||
BITVEC base;
|
BITVEC base;
|
||||||
int4 len = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
|
int4 i,len;
|
||||||
int4 i;
|
|
||||||
int4 flag = 0;
|
int4 flag = 0;
|
||||||
GISTTYPE *result;
|
GISTTYPE *result;
|
||||||
|
|
||||||
MemSet((void *) base, 0, sizeof(BITVEC));
|
MemSet((void *) base, 0, sizeof(BITVEC));
|
||||||
for (i = 0; i < len; i++)
|
for (i = 0; i < entryvec->n; i++)
|
||||||
{
|
{
|
||||||
if (unionkey(base, GETENTRY(entryvec, i)))
|
if (unionkey(base, GETENTRY(entryvec, i)))
|
||||||
{
|
{
|
||||||
|
@ -526,7 +525,7 @@ hemdistcache(CACHESIGN *a, CACHESIGN *b) {
|
||||||
Datum
|
Datum
|
||||||
gtsvector_picksplit(PG_FUNCTION_ARGS)
|
gtsvector_picksplit(PG_FUNCTION_ARGS)
|
||||||
{
|
{
|
||||||
bytea *entryvec = (bytea *) PG_GETARG_POINTER(0);
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
||||||
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
||||||
OffsetNumber k,
|
OffsetNumber k,
|
||||||
j;
|
j;
|
||||||
|
@ -549,7 +548,7 @@ gtsvector_picksplit(PG_FUNCTION_ARGS)
|
||||||
CACHESIGN *cache;
|
CACHESIGN *cache;
|
||||||
SPLITCOST *costvector;
|
SPLITCOST *costvector;
|
||||||
|
|
||||||
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
|
maxoff = entryvec->n - 2;
|
||||||
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
||||||
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
||||||
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
||||||
|
|
|
@ -581,7 +581,7 @@ RETURNS internal
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
|
||||||
CREATE FUNCTION gtsvector_union(bytea, internal)
|
CREATE FUNCTION gtsvector_union(internal, internal)
|
||||||
RETURNS _int4
|
RETURNS _int4
|
||||||
AS 'MODULE_PATHNAME'
|
AS 'MODULE_PATHNAME'
|
||||||
LANGUAGE 'C';
|
LANGUAGE 'C';
|
||||||
|
@ -597,7 +597,7 @@ DEFAULT FOR TYPE tsvector USING gist
|
||||||
AS
|
AS
|
||||||
OPERATOR 1 @@ (tsvector, tsquery) RECHECK ,
|
OPERATOR 1 @@ (tsvector, tsquery) RECHECK ,
|
||||||
FUNCTION 1 gtsvector_consistent (gtsvector, internal, int4),
|
FUNCTION 1 gtsvector_consistent (gtsvector, internal, int4),
|
||||||
FUNCTION 2 gtsvector_union (bytea, internal),
|
FUNCTION 2 gtsvector_union (internal, internal),
|
||||||
FUNCTION 3 gtsvector_compress (internal),
|
FUNCTION 3 gtsvector_compress (internal),
|
||||||
FUNCTION 4 gtsvector_decompress (internal),
|
FUNCTION 4 gtsvector_decompress (internal),
|
||||||
FUNCTION 5 gtsvector_penalty (internal, internal, internal),
|
FUNCTION 5 gtsvector_penalty (internal, internal, internal),
|
||||||
|
|
|
@ -57,7 +57,7 @@ DROP FUNCTION gtsvector_compress(internal);
|
||||||
DROP FUNCTION gtsvector_decompress(internal);
|
DROP FUNCTION gtsvector_decompress(internal);
|
||||||
DROP FUNCTION gtsvector_penalty(internal,internal,internal);
|
DROP FUNCTION gtsvector_penalty(internal,internal,internal);
|
||||||
DROP FUNCTION gtsvector_picksplit(internal, internal);
|
DROP FUNCTION gtsvector_picksplit(internal, internal);
|
||||||
DROP FUNCTION gtsvector_union(bytea, internal);
|
DROP FUNCTION gtsvector_union(internal, internal);
|
||||||
DROP FUNCTION reset_tsearch();
|
DROP FUNCTION reset_tsearch();
|
||||||
DROP FUNCTION tsearch2() CASCADE;
|
DROP FUNCTION tsearch2() CASCADE;
|
||||||
DROP FUNCTION _get_parser_from_curcfg();
|
DROP FUNCTION _get_parser_from_curcfg();
|
||||||
|
|
|
@ -8,7 +8,7 @@
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California
|
* Portions Copyright (c) 1994, Regents of the University of California
|
||||||
*
|
*
|
||||||
* IDENTIFICATION
|
* IDENTIFICATION
|
||||||
* $PostgreSQL: pgsql/src/backend/access/gist/gist.c,v 1.108 2004/02/10 03:42:42 tgl Exp $
|
* $PostgreSQL: pgsql/src/backend/access/gist/gist.c,v 1.109 2004/03/30 15:45:33 teodor Exp $
|
||||||
*
|
*
|
||||||
*-------------------------------------------------------------------------
|
*-------------------------------------------------------------------------
|
||||||
*/
|
*/
|
||||||
|
@ -667,8 +667,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
Datum attr[INDEX_MAX_KEYS];
|
Datum attr[INDEX_MAX_KEYS];
|
||||||
bool whatfree[INDEX_MAX_KEYS];
|
bool whatfree[INDEX_MAX_KEYS];
|
||||||
char isnull[INDEX_MAX_KEYS];
|
char isnull[INDEX_MAX_KEYS];
|
||||||
char *storage;
|
GistEntryVector *evec;
|
||||||
bytea *evec;
|
|
||||||
Datum datum;
|
Datum datum;
|
||||||
int datumsize,
|
int datumsize,
|
||||||
i,
|
i,
|
||||||
|
@ -680,9 +679,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
int reallen;
|
int reallen;
|
||||||
|
|
||||||
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
|
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
|
||||||
/* workaround for 64-bit: ensure GISTENTRY array is maxaligned */
|
evec = (GistEntryVector *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||||
storage = (char *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + MAXALIGN(VARHDRSZ));
|
|
||||||
evec = (bytea *) (storage + MAXALIGN(VARHDRSZ) - VARHDRSZ);
|
|
||||||
|
|
||||||
for (j = 0; j < r->rd_att->natts; j++)
|
for (j = 0; j < r->rd_att->natts; j++)
|
||||||
{
|
{
|
||||||
|
@ -694,12 +691,12 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
gistdentryinit(giststate, j,
|
gistdentryinit(giststate, j,
|
||||||
&((GISTENTRY *) VARDATA(evec))[reallen],
|
&(evec->vector[reallen]),
|
||||||
datum,
|
datum,
|
||||||
NULL, NULL, (OffsetNumber) 0,
|
NULL, NULL, (OffsetNumber) 0,
|
||||||
ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
|
ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
|
||||||
if ((!isAttByVal(giststate, j)) &&
|
if ((!isAttByVal(giststate, j)) &&
|
||||||
((GISTENTRY *) VARDATA(evec))[reallen].key != datum)
|
evec->vector[reallen].key != datum)
|
||||||
needfree[reallen] = TRUE;
|
needfree[reallen] = TRUE;
|
||||||
else
|
else
|
||||||
needfree[reallen] = FALSE;
|
needfree[reallen] = FALSE;
|
||||||
|
@ -716,21 +713,21 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
{
|
{
|
||||||
if (reallen == 1)
|
if (reallen == 1)
|
||||||
{
|
{
|
||||||
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
|
evec->n = 2;
|
||||||
gistentryinit(((GISTENTRY *) VARDATA(evec))[1],
|
gistentryinit(evec->vector[1],
|
||||||
((GISTENTRY *) VARDATA(evec))[0].key, r, NULL,
|
evec->vector[0].key, r, NULL,
|
||||||
(OffsetNumber) 0, ((GISTENTRY *) VARDATA(evec))[0].bytes, FALSE);
|
(OffsetNumber) 0, evec->vector[0].bytes, FALSE);
|
||||||
|
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
|
evec->n = reallen;
|
||||||
datum = FunctionCall2(&giststate->unionFn[j],
|
datum = FunctionCall2(&giststate->unionFn[j],
|
||||||
PointerGetDatum(evec),
|
PointerGetDatum(evec),
|
||||||
PointerGetDatum(&datumsize));
|
PointerGetDatum(&datumsize));
|
||||||
|
|
||||||
for (i = 0; i < reallen; i++)
|
for (i = 0; i < reallen; i++)
|
||||||
if (needfree[i])
|
if (needfree[i])
|
||||||
pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key));
|
pfree(DatumGetPointer(evec->vector[i].key));
|
||||||
|
|
||||||
gistcentryinit(giststate, j, ¢ry[j], datum,
|
gistcentryinit(giststate, j, ¢ry[j], datum,
|
||||||
NULL, NULL, (OffsetNumber) 0,
|
NULL, NULL, (OffsetNumber) 0,
|
||||||
|
@ -748,7 +745,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pfree(storage); /* pfree(evec); */
|
pfree(evec);
|
||||||
pfree(needfree);
|
pfree(needfree);
|
||||||
|
|
||||||
newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
|
newtup = (IndexTuple) index_formtuple(giststate->tupdesc, attr, isnull);
|
||||||
|
@ -766,7 +763,7 @@ gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
|
||||||
static IndexTuple
|
static IndexTuple
|
||||||
gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate)
|
gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate)
|
||||||
{
|
{
|
||||||
bytea *evec;
|
GistEntryVector *evec;
|
||||||
Datum datum;
|
Datum datum;
|
||||||
int datumsize;
|
int datumsize;
|
||||||
bool result,
|
bool result,
|
||||||
|
@ -784,15 +781,12 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||||
bool oldisnull[INDEX_MAX_KEYS],
|
bool oldisnull[INDEX_MAX_KEYS],
|
||||||
addisnull[INDEX_MAX_KEYS];
|
addisnull[INDEX_MAX_KEYS];
|
||||||
IndexTuple newtup = NULL;
|
IndexTuple newtup = NULL;
|
||||||
char *storage;
|
|
||||||
int j;
|
int j;
|
||||||
|
|
||||||
/* workaround for 64-bit: ensure GISTENTRY array is maxaligned */
|
evec = palloc(2 * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||||
storage = (char *) palloc(2 * sizeof(GISTENTRY) + MAXALIGN(VARHDRSZ));
|
evec->n = 2;
|
||||||
evec = (bytea *) (storage + MAXALIGN(VARHDRSZ) - VARHDRSZ);
|
ev0p = &(evec->vector[0]);
|
||||||
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
|
ev1p = &(evec->vector[1]);
|
||||||
ev0p = &((GISTENTRY *) VARDATA(evec))[0];
|
|
||||||
ev1p = &((GISTENTRY *) VARDATA(evec))[1];
|
|
||||||
|
|
||||||
gistDeCompressAtt(giststate, r, oldtup, NULL,
|
gistDeCompressAtt(giststate, r, oldtup, NULL,
|
||||||
(OffsetNumber) 0, oldatt, olddec, oldisnull);
|
(OffsetNumber) 0, oldatt, olddec, oldisnull);
|
||||||
|
@ -857,7 +851,7 @@ gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *gis
|
||||||
whatfree[j] = FALSE;
|
whatfree[j] = FALSE;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pfree(storage); /* pfree(evec); */
|
pfree(evec);
|
||||||
|
|
||||||
if (neednew)
|
if (neednew)
|
||||||
{
|
{
|
||||||
|
@ -885,8 +879,7 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||||
int len,
|
int len,
|
||||||
*attrsize;
|
*attrsize;
|
||||||
OffsetNumber *entries;
|
OffsetNumber *entries;
|
||||||
bytea *evec;
|
GistEntryVector *evec;
|
||||||
char *storage;
|
|
||||||
Datum datum;
|
Datum datum;
|
||||||
int datumsize;
|
int datumsize;
|
||||||
int reallen;
|
int reallen;
|
||||||
|
@ -912,9 +905,7 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||||
}
|
}
|
||||||
|
|
||||||
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
|
needfree = (bool *) palloc(((len == 1) ? 2 : len) * sizeof(bool));
|
||||||
/* workaround for 64-bit: ensure GISTENTRY array is maxaligned */
|
evec = palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||||
storage = (char *) palloc(((len == 1) ? 2 : len) * sizeof(GISTENTRY) + MAXALIGN(VARHDRSZ));
|
|
||||||
evec = (bytea *) (storage + MAXALIGN(VARHDRSZ) - VARHDRSZ);
|
|
||||||
|
|
||||||
for (j = 1; j < r->rd_att->natts; j++)
|
for (j = 1; j < r->rd_att->natts; j++)
|
||||||
{
|
{
|
||||||
|
@ -928,12 +919,12 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||||
if (IsNull)
|
if (IsNull)
|
||||||
continue;
|
continue;
|
||||||
gistdentryinit(giststate, j,
|
gistdentryinit(giststate, j,
|
||||||
&((GISTENTRY *) VARDATA(evec))[reallen],
|
&(evec->vector[reallen]),
|
||||||
datum,
|
datum,
|
||||||
NULL, NULL, (OffsetNumber) 0,
|
NULL, NULL, (OffsetNumber) 0,
|
||||||
ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
|
ATTSIZE(datum, giststate->tupdesc, j + 1, IsNull), FALSE, IsNull);
|
||||||
if ((!isAttByVal(giststate, j)) &&
|
if ((!isAttByVal(giststate, j)) &&
|
||||||
((GISTENTRY *) VARDATA(evec))[reallen].key != datum)
|
evec->vector[reallen].key != datum)
|
||||||
needfree[reallen] = TRUE;
|
needfree[reallen] = TRUE;
|
||||||
else
|
else
|
||||||
needfree[reallen] = FALSE;
|
needfree[reallen] = FALSE;
|
||||||
|
@ -949,18 +940,18 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
/*
|
/*
|
||||||
* ((GISTENTRY *) VARDATA(evec))[0].bytes may be not
|
* evec->vector[0].bytes may be not
|
||||||
* defined, so form union with itself
|
* defined, so form union with itself
|
||||||
*/
|
*/
|
||||||
if (reallen == 1)
|
if (reallen == 1)
|
||||||
{
|
{
|
||||||
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
|
evec->n = 2;
|
||||||
memcpy((void *) &((GISTENTRY *) VARDATA(evec))[1],
|
memcpy((void *) &(evec->vector[1]),
|
||||||
(void *) &((GISTENTRY *) VARDATA(evec))[0],
|
(void *) &(evec->vector[0]),
|
||||||
sizeof(GISTENTRY));
|
sizeof(GISTENTRY));
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
VARATT_SIZEP(evec) = reallen * sizeof(GISTENTRY) + VARHDRSZ;
|
evec->n = reallen;
|
||||||
datum = FunctionCall2(&giststate->unionFn[j],
|
datum = FunctionCall2(&giststate->unionFn[j],
|
||||||
PointerGetDatum(evec),
|
PointerGetDatum(evec),
|
||||||
PointerGetDatum(&datumsize));
|
PointerGetDatum(&datumsize));
|
||||||
|
@ -969,12 +960,12 @@ gistunionsubkey(Relation r, GISTSTATE *giststate, IndexTuple *itvec, GIST_SPLITV
|
||||||
|
|
||||||
for (i = 0; i < reallen; i++)
|
for (i = 0; i < reallen; i++)
|
||||||
if (needfree[i])
|
if (needfree[i])
|
||||||
pfree(DatumGetPointer(((GISTENTRY *) VARDATA(evec))[i].key));
|
pfree(DatumGetPointer(evec->vector[i].key));
|
||||||
|
|
||||||
attr[j] = datum;
|
attr[j] = datum;
|
||||||
attrsize[j] = datumsize;
|
attrsize[j] = datumsize;
|
||||||
}
|
}
|
||||||
pfree(storage); /* pfree(evec); */
|
pfree(evec);
|
||||||
pfree(needfree);
|
pfree(needfree);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1065,8 +1056,7 @@ gistadjsubkey(Relation r,
|
||||||
*ev1p;
|
*ev1p;
|
||||||
float lpenalty,
|
float lpenalty,
|
||||||
rpenalty;
|
rpenalty;
|
||||||
bytea *evec;
|
GistEntryVector *evec;
|
||||||
char *storage;
|
|
||||||
int datumsize;
|
int datumsize;
|
||||||
bool isnull[INDEX_MAX_KEYS];
|
bool isnull[INDEX_MAX_KEYS];
|
||||||
int i,
|
int i,
|
||||||
|
@ -1098,12 +1088,10 @@ gistadjsubkey(Relation r,
|
||||||
curlen--;
|
curlen--;
|
||||||
v->spl_nright = curlen;
|
v->spl_nright = curlen;
|
||||||
|
|
||||||
/* workaround for 64-bit: ensure GISTENTRY array is maxaligned */
|
evec = palloc(2 * sizeof(GISTENTRY) + GEVHDRSZ);
|
||||||
storage = (char *) palloc(2 * sizeof(GISTENTRY) + MAXALIGN(VARHDRSZ));
|
evec->n = 2;
|
||||||
evec = (bytea *) (storage + MAXALIGN(VARHDRSZ) - VARHDRSZ);
|
ev0p = &(evec->vector[0]);
|
||||||
VARATT_SIZEP(evec) = 2 * sizeof(GISTENTRY) + VARHDRSZ;
|
ev1p = &(evec->vector[1]);
|
||||||
ev0p = &((GISTENTRY *) VARDATA(evec))[0];
|
|
||||||
ev1p = &((GISTENTRY *) VARDATA(evec))[1];
|
|
||||||
|
|
||||||
/* add equivalent tuple */
|
/* add equivalent tuple */
|
||||||
for (i = 0; i < *len; i++)
|
for (i = 0; i < *len; i++)
|
||||||
|
@ -1208,7 +1196,7 @@ gistadjsubkey(Relation r,
|
||||||
}
|
}
|
||||||
gistFreeAtt(r, identry, decfree);
|
gistFreeAtt(r, identry, decfree);
|
||||||
}
|
}
|
||||||
pfree(storage); /* pfree(evec); */
|
pfree(evec);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -1234,8 +1222,7 @@ gistSplit(Relation r,
|
||||||
rbknum;
|
rbknum;
|
||||||
GISTPageOpaque opaque;
|
GISTPageOpaque opaque;
|
||||||
GIST_SPLITVEC v;
|
GIST_SPLITVEC v;
|
||||||
bytea *entryvec;
|
GistEntryVector *entryvec;
|
||||||
char *storage;
|
|
||||||
bool *decompvec;
|
bool *decompvec;
|
||||||
int i,
|
int i,
|
||||||
j,
|
j,
|
||||||
|
@ -1274,18 +1261,16 @@ gistSplit(Relation r,
|
||||||
right = (Page) BufferGetPage(rightbuf);
|
right = (Page) BufferGetPage(rightbuf);
|
||||||
|
|
||||||
/* generate the item array */
|
/* generate the item array */
|
||||||
/* workaround for 64-bit: ensure GISTENTRY array is maxaligned */
|
entryvec = palloc(GEVHDRSZ + (*len + 1) * sizeof(GISTENTRY));
|
||||||
storage = palloc(MAXALIGN(VARHDRSZ) + (*len + 1) * sizeof(GISTENTRY));
|
entryvec->n = *len + 1;
|
||||||
entryvec = (bytea *) (storage + MAXALIGN(VARHDRSZ) - VARHDRSZ);
|
|
||||||
decompvec = (bool *) palloc((*len + 1) * sizeof(bool));
|
decompvec = (bool *) palloc((*len + 1) * sizeof(bool));
|
||||||
VARATT_SIZEP(entryvec) = (*len + 1) * sizeof(GISTENTRY) + VARHDRSZ;
|
|
||||||
for (i = 1; i <= *len; i++)
|
for (i = 1; i <= *len; i++)
|
||||||
{
|
{
|
||||||
datum = index_getattr(itup[i - 1], 1, giststate->tupdesc, &IsNull);
|
datum = index_getattr(itup[i - 1], 1, giststate->tupdesc, &IsNull);
|
||||||
gistdentryinit(giststate, 0, &((GISTENTRY *) VARDATA(entryvec))[i],
|
gistdentryinit(giststate, 0, &(entryvec->vector[i]),
|
||||||
datum, r, p, i,
|
datum, r, p, i,
|
||||||
ATTSIZE(datum, giststate->tupdesc, 1, IsNull), FALSE, IsNull);
|
ATTSIZE(datum, giststate->tupdesc, 1, IsNull), FALSE, IsNull);
|
||||||
if ((!isAttByVal(giststate, 0)) && ((GISTENTRY *) VARDATA(entryvec))[i].key != datum)
|
if ((!isAttByVal(giststate, 0)) && entryvec->vector[i].key != datum)
|
||||||
decompvec[i] = TRUE;
|
decompvec[i] = TRUE;
|
||||||
else
|
else
|
||||||
decompvec[i] = FALSE;
|
decompvec[i] = FALSE;
|
||||||
|
@ -1320,7 +1305,7 @@ gistSplit(Relation r,
|
||||||
v.spl_grpflag = (char *) palloc0(sizeof(char) * (*len + 1));
|
v.spl_grpflag = (char *) palloc0(sizeof(char) * (*len + 1));
|
||||||
v.spl_ngrp = (int *) palloc(sizeof(int) * (*len + 1));
|
v.spl_ngrp = (int *) palloc(sizeof(int) * (*len + 1));
|
||||||
|
|
||||||
MaxGrpId = gistfindgroup(giststate, (GISTENTRY *) VARDATA(entryvec), &v);
|
MaxGrpId = gistfindgroup(giststate, entryvec->vector, &v);
|
||||||
|
|
||||||
/* form union of sub keys for each page (l,p) */
|
/* form union of sub keys for each page (l,p) */
|
||||||
gistunionsubkey(r, giststate, itup, &v);
|
gistunionsubkey(r, giststate, itup, &v);
|
||||||
|
@ -1340,8 +1325,8 @@ gistSplit(Relation r,
|
||||||
/* clean up the entry vector: its keys need to be deleted, too */
|
/* clean up the entry vector: its keys need to be deleted, too */
|
||||||
for (i = 1; i <= *len; i++)
|
for (i = 1; i <= *len; i++)
|
||||||
if (decompvec[i])
|
if (decompvec[i])
|
||||||
pfree(DatumGetPointer(((GISTENTRY *) VARDATA(entryvec))[i].key));
|
pfree(DatumGetPointer(entryvec->vector[i].key));
|
||||||
pfree(storage); /* pfree(entryvec); */
|
pfree(entryvec);
|
||||||
pfree(decompvec);
|
pfree(decompvec);
|
||||||
|
|
||||||
/* form left and right vector */
|
/* form left and right vector */
|
||||||
|
|
|
@ -7,7 +7,7 @@
|
||||||
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
|
||||||
* Portions Copyright (c) 1994, Regents of the University of California
|
* Portions Copyright (c) 1994, Regents of the University of California
|
||||||
*
|
*
|
||||||
* $PostgreSQL: pgsql/src/include/access/gist.h,v 1.39 2003/11/29 22:40:55 pgsql Exp $
|
* $PostgreSQL: pgsql/src/include/access/gist.h,v 1.40 2004/03/30 15:45:33 teodor Exp $
|
||||||
*
|
*
|
||||||
*-------------------------------------------------------------------------
|
*-------------------------------------------------------------------------
|
||||||
*/
|
*/
|
||||||
|
@ -157,6 +157,19 @@ typedef struct GISTENTRY
|
||||||
bool leafkey;
|
bool leafkey;
|
||||||
} GISTENTRY;
|
} GISTENTRY;
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Vector of GISTENTRY struct's, user-defined
|
||||||
|
* methods union andpick split takes it as one of args
|
||||||
|
*/
|
||||||
|
|
||||||
|
typedef struct {
|
||||||
|
int32 n; /* number of elements */
|
||||||
|
GISTENTRY vector[1];
|
||||||
|
} GistEntryVector;
|
||||||
|
|
||||||
|
#define GEVHDRSZ ( offsetof(GistEntryVector, vector[0]) )
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* macro to initialize a GISTENTRY
|
* macro to initialize a GISTENTRY
|
||||||
*/
|
*/
|
||||||
|
|
Loading…
Reference in New Issue