tsquery_gist.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * tsquery_gist.c
 *    GiST index support for tsquery
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 *
 *
 * IDENTIFICATION
 *    src/backend/utils/adt/tsquery_gist.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "access/gist.h"
#include "access/stratnum.h"
#include "common/int.h"
#include "tsearch/ts_utils.h"
#include "utils/fmgrprotos.h"
 
#define GETENTRY(vec,pos) DatumGetTSQuerySign((vec)->vector[pos].key)
 
 
Datum
gtsquery_compress(PG_FUNCTION_ARGS)
{
    GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
    GISTENTRY  *retval = entry;
 
    if (entry->leafkey)
    {
        TSQuerySign sign;
 
        retval = palloc_object(GISTENTRY);
        sign = makeTSQuerySign(DatumGetTSQuery(entry->key));
 
        gistentryinit(*retval, TSQuerySignGetDatum(sign),
                      entry->rel, entry->page,
                      entry->offset, false);
    }
 
    PG_RETURN_POINTER(retval);
}
 
/*
 * 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);
    TSQuery     query = PG_GETARG_TSQUERY(1);
    StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
#ifdef NOT_USED
    Oid         subtype = PG_GETARG_OID(3);
#endif
    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;
            else
                retval = (key & sq) != 0;
            break;
        case RTContainedByStrategyNumber:
            if (GIST_LEAF(entry))
                retval = (key & sq) == key;
            else
                retval = (key & sq) != 0;
            break;
        default:
            retval = false;
    }
    PG_RETURN_BOOL(retval);
}
 
Datum
gtsquery_union(PG_FUNCTION_ARGS)
{
    GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
    int        *size = (int *) PG_GETARG_POINTER(1);
    TSQuerySign sign;
    int         i;
 
    sign = 0;
 
    for (i = 0; i < entryvec->n; i++)
        sign |= GETENTRY(entryvec, i);
 
    *size = sizeof(TSQuerySign);
 
    PG_RETURN_TSQUERYSIGN(sign);
}
 
Datum
gtsquery_same(PG_FUNCTION_ARGS)
{
    TSQuerySign a = PG_GETARG_TSQUERYSIGN(0);
    TSQuerySign b = PG_GETARG_TSQUERYSIGN(1);
    bool       *result = (bool *) PG_GETARG_POINTER(2);
 
    *result = (a == b);
 
    PG_RETURN_POINTER(result);
}
 
static int
sizebitvec(TSQuerySign sign)
{
    int         size = 0,
                i;
 
    for (i = 0; i < TSQS_SIGLEN; i++)
        size += 0x01 & (sign >> i);
 
    return size;
}
 
static int
hemdist(TSQuerySign a, TSQuerySign b)
{
    TSQuerySign res = a ^ b;
 
    return sizebitvec(res);
}
 
Datum
gtsquery_penalty(PG_FUNCTION_ARGS)
{
    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);
 
    PG_RETURN_POINTER(penalty);
}
 
 
typedef struct
{
    OffsetNumber pos;
    int32       cost;
} SPLITCOST;
 
static int
comparecost(const void *a, const void *b)
{
    return pg_cmp_s32(((const SPLITCOST *) a)->cost,
                      ((const SPLITCOST *) b)->cost);
}
 
#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
 
Datum
gtsquery_picksplit(PG_FUNCTION_ARGS)
{
    GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
    GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
    OffsetNumber maxoff = entryvec->n - 2;
    OffsetNumber k,
                j;
    TSQuerySign datum_l,
                datum_r;
    int32       size_alpha,
                size_beta;
    int32       size_waste,
                waste = -1;
    int32       nbytes;
    OffsetNumber seed_1 = 0,
                seed_2 = 0;
    OffsetNumber *left,
               *right;
 
    SPLITCOST  *costvector;
 
    nbytes = (maxoff + 2) * sizeof(OffsetNumber);
    left = v->spl_left = (OffsetNumber *) palloc(nbytes);
    right = v->spl_right = (OffsetNumber *) palloc(nbytes);
    v->spl_nleft = v->spl_nright = 0;
 
    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));
            if (size_waste > waste)
            {
                waste = size_waste;
                seed_1 = k;
                seed_2 = j;
            }
        }
 
 
    if (seed_1 == 0 || seed_2 == 0)
    {
        seed_1 = 1;
        seed_2 = 2;
    }
 
    datum_l = GETENTRY(entryvec, seed_1);
    datum_r = GETENTRY(entryvec, seed_2);
 
    maxoff = OffsetNumberNext(maxoff);
    costvector = palloc_array(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));
        costvector[j - 1].cost = abs(size_alpha - size_beta);
    }
    qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
 
    for (k = 0; k < maxoff; k++)
    {
        j = costvector[k].pos;
        if (j == seed_1)
        {
            *left++ = j;
            v->spl_nleft++;
            continue;
        }
        else if (j == seed_2)
        {
            *right++ = j;
            v->spl_nright++;
            continue;
        }
        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);
            *left++ = j;
            v->spl_nleft++;
        }
        else
        {
            datum_r |= GETENTRY(entryvec, j);
            *right++ = j;
            v->spl_nright++;
        }
    }
 
    *right = *left = FirstOffsetNumber;
    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);
}