* tsquery_gist.c
* GiST index support for tsquery
*
- * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/tsquery_gist.c,v 1.4 2008/01/01 19:45:53 momjian Exp $
+ * src/backend/utils/adt/tsquery_gist.c
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
-#include "access/skey.h"
+#include "access/stratnum.h"
#include "access/gist.h"
-#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
+#include "utils/builtins.h"
+
+#define GETENTRY(vec,pos) DatumGetTSQuerySign((vec)->vector[pos].key)
-#define GETENTRY(vec,pos) ((TSQuerySign *) DatumGetPointer((vec)->vector[(pos)].key))
Datum
gtsquery_compress(PG_FUNCTION_ARGS)
if (entry->leafkey)
{
- TSQuerySign *sign = (TSQuerySign *) palloc(sizeof(TSQuerySign));
+ TSQuerySign sign;
retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
- *sign = makeTSQuerySign(DatumGetTSQuery(entry->key));
+ sign = makeTSQuerySign(DatumGetTSQuery(entry->key));
- gistentryinit(*retval, PointerGetDatum(sign),
+ gistentryinit(*retval, TSQuerySignGetDatum(sign),
entry->rel, entry->page,
- entry->offset, FALSE);
+ entry->offset, false);
}
PG_RETURN_POINTER(retval);
}
-Datum
-gtsquery_decompress(PG_FUNCTION_ARGS)
-{
- PG_RETURN_DATUM(PG_GETARG_DATUM(0));
-}
+/*
+ * We do not need a decompress function, because the other gtsquery
+ * support functions work with the compressed representation.
+ */
Datum
gtsquery_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- TSQuerySign *key = (TSQuerySign *) DatumGetPointer(entry->key);
TSQuery query = PG_GETARG_TSQUERY(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
+ /* Oid subtype = PG_GETARG_OID(3); */
+ bool *recheck = (bool *) PG_GETARG_POINTER(4);
+ TSQuerySign key = DatumGetTSQuerySign(entry->key);
TSQuerySign sq = makeTSQuerySign(query);
bool retval;
+ /* All cases served by this function are inexact */
+ *recheck = true;
+
switch (strategy)
{
case RTContainsStrategyNumber:
if (GIST_LEAF(entry))
- retval = (*key & sq) == sq;
+ retval = (key & sq) == sq;
else
- retval = (*key & sq) != 0;
+ retval = (key & sq) != 0;
break;
case RTContainedByStrategyNumber:
if (GIST_LEAF(entry))
- retval = (*key & sq) == *key;
+ retval = (key & sq) == key;
else
- retval = (*key & sq) != 0;
+ retval = (key & sq) != 0;
break;
default:
- retval = FALSE;
+ retval = false;
}
PG_RETURN_BOOL(retval);
}
{
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
int *size = (int *) PG_GETARG_POINTER(1);
- TSQuerySign *sign = (TSQuerySign *) palloc(sizeof(TSQuerySign));
+ TSQuerySign sign;
int i;
- memset(sign, 0, sizeof(TSQuerySign));
+ sign = 0;
for (i = 0; i < entryvec->n; i++)
- *sign |= *GETENTRY(entryvec, i);
+ sign |= GETENTRY(entryvec, i);
*size = sizeof(TSQuerySign);
- PG_RETURN_POINTER(sign);
+ PG_RETURN_TSQUERYSIGN(sign);
}
Datum
gtsquery_same(PG_FUNCTION_ARGS)
{
- TSQuerySign *a = (TSQuerySign *) PG_GETARG_POINTER(0);
- TSQuerySign *b = (TSQuerySign *) PG_GETARG_POINTER(1);
+ TSQuerySign a = PG_GETARG_TSQUERYSIGN(0);
+ TSQuerySign b = PG_GETARG_TSQUERYSIGN(1);
+ bool *result = (bool *) PG_GETARG_POINTER(2);
+
+ *result = (a == b) ? true : false;
- PG_RETURN_POINTER(*a == *b);
+ PG_RETURN_POINTER(result);
}
static int
Datum
gtsquery_penalty(PG_FUNCTION_ARGS)
{
- TSQuerySign *origval = (TSQuerySign *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
- TSQuerySign *newval = (TSQuerySign *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
+ TSQuerySign origval = DatumGetTSQuerySign(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
+ TSQuerySign newval = DatumGetTSQuerySign(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *penalty = (float *) PG_GETARG_POINTER(2);
- *penalty = hemdist(*origval, *newval);
+ *penalty = hemdist(origval, newval);
PG_RETURN_POINTER(penalty);
}
typedef struct
{
OffsetNumber pos;
- int4 cost;
+ int32 cost;
} SPLITCOST;
static int
comparecost(const void *a, const void *b)
{
- if (((SPLITCOST *) a)->cost == ((SPLITCOST *) b)->cost)
+ if (((const SPLITCOST *) a)->cost == ((const SPLITCOST *) b)->cost)
return 0;
else
- return (((SPLITCOST *) a)->cost > ((SPLITCOST *) b)->cost) ? 1 : -1;
+ return (((const SPLITCOST *) a)->cost > ((const SPLITCOST *) b)->cost) ? 1 : -1;
}
#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
OffsetNumber maxoff = entryvec->n - 2;
OffsetNumber k,
j;
-
- TSQuerySign *datum_l,
- *datum_r;
- int4 size_alpha,
+ TSQuerySign datum_l,
+ datum_r;
+ int32 size_alpha,
size_beta;
- int4 size_waste,
+ int32 size_waste,
waste = -1;
- int4 nbytes;
+ int32 nbytes;
OffsetNumber seed_1 = 0,
seed_2 = 0;
OffsetNumber *left,
for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
{
- size_waste = hemdist(*GETENTRY(entryvec, j), *GETENTRY(entryvec, k));
+ size_waste = hemdist(GETENTRY(entryvec, j), GETENTRY(entryvec, k));
if (size_waste > waste)
{
waste = size_waste;
seed_2 = 2;
}
- datum_l = (TSQuerySign *) palloc(sizeof(TSQuerySign));
- *datum_l = *GETENTRY(entryvec, seed_1);
- datum_r = (TSQuerySign *) palloc(sizeof(TSQuerySign));
- *datum_r = *GETENTRY(entryvec, seed_2);
-
+ datum_l = GETENTRY(entryvec, seed_1);
+ datum_r = GETENTRY(entryvec, seed_2);
maxoff = OffsetNumberNext(maxoff);
costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
{
costvector[j - 1].pos = j;
- size_alpha = hemdist(*GETENTRY(entryvec, seed_1), *GETENTRY(entryvec, j));
- size_beta = hemdist(*GETENTRY(entryvec, seed_2), *GETENTRY(entryvec, j));
+ size_alpha = hemdist(GETENTRY(entryvec, seed_1), GETENTRY(entryvec, j));
+ size_beta = hemdist(GETENTRY(entryvec, seed_2), GETENTRY(entryvec, j));
costvector[j - 1].cost = abs(size_alpha - size_beta);
}
qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
v->spl_nright++;
continue;
}
- size_alpha = hemdist(*datum_l, *GETENTRY(entryvec, j));
- size_beta = hemdist(*datum_r, *GETENTRY(entryvec, j));
+ size_alpha = hemdist(datum_l, GETENTRY(entryvec, j));
+ size_beta = hemdist(datum_r, GETENTRY(entryvec, j));
if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.05))
{
- *datum_l |= *GETENTRY(entryvec, j);
+ datum_l |= GETENTRY(entryvec, j);
*left++ = j;
v->spl_nleft++;
}
else
{
- *datum_r |= *GETENTRY(entryvec, j);
+ datum_r |= GETENTRY(entryvec, j);
*right++ = j;
v->spl_nright++;
}
}
*right = *left = FirstOffsetNumber;
- v->spl_ldatum = PointerGetDatum(datum_l);
- v->spl_rdatum = PointerGetDatum(datum_r);
+ v->spl_ldatum = TSQuerySignGetDatum(datum_l);
+ v->spl_rdatum = TSQuerySignGetDatum(datum_r);
PG_RETURN_POINTER(v);
}
+
+/*
+ * Formerly, gtsquery_consistent was declared in pg_proc.h with arguments
+ * that did not match the documented conventions for GiST support functions.
+ * We fixed that, but we still need a pg_proc entry with the old signature
+ * to support reloading pre-9.6 contrib/tsearch2 opclass declarations.
+ * This compatibility function should go away eventually.
+ */
+Datum
+gtsquery_consistent_oldsig(PG_FUNCTION_ARGS)
+{
+ return gtsquery_consistent(fcinfo);
+}
projects / postgresql / blobdiff