gistutil.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/gist_private.h"
#include "access/htup_details.h"
#include "access/reloptions.h"
#include "catalog/pg_opclass.h"
#include "common/pg_prng.h"
#include "storage/indexfsm.h"
#include "storage/lmgr.h"
#include "utils/float.h"
#include "utils/lsyscache.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for gistutil.c:

Go to the source code of this file.

Functions
void	gistfillbuffer (Page page, IndexTuple *itup, int len, OffsetNumber off)
bool	gistnospace (Page page, IndexTuple *itvec, int len, OffsetNumber todelete, Size freespace)
bool	gistfitpage (IndexTuple *itvec, int len)
IndexTuple *	gistextractpage (Page page, int *len)
IndexTuple *	gistjoinvector (IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
IndexTupleData *	gistfillitupvec (IndexTuple *vec, int veclen, int *memlen)
void	gistMakeUnionItVec (GISTSTATE *giststate, IndexTuple *itvec, int len, Datum *attr, bool *isnull)
IndexTuple	gistunion (Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
void	gistMakeUnionKey (GISTSTATE *giststate, int attno, GISTENTRY *entry1, bool isnull1, GISTENTRY *entry2, bool isnull2, Datum *dst, bool *dstisnull)
bool	gistKeyIsEQ (GISTSTATE *giststate, int attno, Datum a, Datum b)
void	gistDeCompressAtt (GISTSTATE *giststate, Relation r, IndexTuple tuple, Page p, OffsetNumber o, GISTENTRY *attdata, bool *isnull)
IndexTuple	gistgetadjusted (Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate)
OffsetNumber	gistchoose (Relation r, Page p, IndexTuple it, GISTSTATE *giststate)
void	gistdentryinit (GISTSTATE *giststate, int nkey, GISTENTRY *e, Datum k, Relation r, Page pg, OffsetNumber o, bool l, bool isNull)
IndexTuple	gistFormTuple (GISTSTATE *giststate, Relation r, Datum *attdata, bool *isnull, bool isleaf)
void	gistCompressValues (GISTSTATE *giststate, Relation r, Datum *attdata, bool *isnull, bool isleaf, Datum *compatt)
static Datum	gistFetchAtt (GISTSTATE *giststate, int nkey, Datum k, Relation r)
HeapTuple	gistFetchTuple (GISTSTATE *giststate, Relation r, IndexTuple tuple)
float	gistpenalty (GISTSTATE *giststate, int attno, GISTENTRY *orig, bool isNullOrig, GISTENTRY *add, bool isNullAdd)
void	gistinitpage (Page page, uint32 f)
void	GISTInitBuffer (Buffer b, uint32 f)
void	gistcheckpage (Relation rel, Buffer buf)
Buffer	gistNewBuffer (Relation r, Relation heaprel)
bool	gistPageRecyclable (Page page)
bytea *	gistoptions (Datum reloptions, bool validate)
bool	gistproperty (Oid index_oid, int attno, IndexAMProperty prop, const char *propname, bool *res, bool *isnull)
XLogRecPtr	gistGetFakeLSN (Relation rel)

Function Documentation

gistcheckpage()

void gistcheckpage	(	Relation	rel,
		Buffer	buf
	)

Definition at line 785 of file gistutil.c.

{
    Page        page = BufferGetPage(buf);
 
    /*
     * ReadBuffer verifies that every newly-read page passes
     * PageHeaderIsValid, which means it either contains a reasonably sane
     * page header or is all-zero.  We have to defend against the all-zero
     * case, however.
     */
    if (PageIsNew(page))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("index \"%s\" contains unexpected zero page at block %u",
                        RelationGetRelationName(rel),
                        BufferGetBlockNumber(buf)),
                 errhint("Please REINDEX it.")));
 
    /*
     * Additionally check that the special area looks sane.
     */
    if (PageGetSpecialSize(page) != MAXALIGN(sizeof(GISTPageOpaqueData)))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("index \"%s\" contains corrupted page at block %u",
                        RelationGetRelationName(rel),
                        BufferGetBlockNumber(buf)),
                 errhint("Please REINDEX it.")));
}

References buf, BufferGetBlockNumber(), BufferGetPage(), ereport, errcode(), errhint(), errmsg(), ERROR, MAXALIGN, PageGetSpecialSize(), PageIsNew(), and RelationGetRelationName.

Referenced by gistBufferingFindCorrectParent(), gistdoinsert(), gistFindCorrectParent(), gistFindPath(), gistkillitems(), gistNewBuffer(), gistScanPage(), gistvacuum_delete_empty_pages(), and pgstat_gist_page().

gistchoose()

OffsetNumber gistchoose	(	Relation	r,
		Page	p,
		IndexTuple	it,
		GISTSTATE *	giststate
	)

Definition at line 374 of file gistutil.c.

{
    OffsetNumber result;
    OffsetNumber maxoff;
    OffsetNumber i;
    float       best_penalty[INDEX_MAX_KEYS];
    GISTENTRY   entry,
                identry[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    int         keep_current_best;
 
    Assert(!GistPageIsLeaf(p));
 
    gistDeCompressAtt(giststate, r,
                      it, NULL, (OffsetNumber) 0,
                      identry, isnull);
 
    /* we'll return FirstOffsetNumber if page is empty (shouldn't happen) */
    result = FirstOffsetNumber;
 
    /*
     * The index may have multiple columns, and there's a penalty value for
     * each column.  The penalty associated with a column that appears earlier
     * in the index definition is strictly more important than the penalty of
     * a column that appears later in the index definition.
     *
     * best_penalty[j] is the best penalty we have seen so far for column j,
     * or -1 when we haven't yet examined column j.  Array entries to the
     * right of the first -1 are undefined.
     */
    best_penalty[0] = -1;
 
    /*
     * If we find a tuple that's exactly as good as the currently best one, we
     * could use either one.  When inserting a lot of tuples with the same or
     * similar keys, it's preferable to descend down the same path when
     * possible, as that's more cache-friendly.  On the other hand, if all
     * inserts land on the same leaf page after a split, we're never going to
     * insert anything to the other half of the split, and will end up using
     * only 50% of the available space.  Distributing the inserts evenly would
     * lead to better space usage, but that hurts cache-locality during
     * insertion.  To get the best of both worlds, when we find a tuple that's
     * exactly as good as the previous best, choose randomly whether to stick
     * to the old best, or use the new one.  Once we decide to stick to the
     * old best, we keep sticking to it for any subsequent equally good tuples
     * we might find.  This favors tuples with low offsets, but still allows
     * some inserts to go to other equally-good subtrees.
     *
     * keep_current_best is -1 if we haven't yet had to make a random choice
     * whether to keep the current best tuple.  If we have done so, and
     * decided to keep it, keep_current_best is 1; if we've decided to
     * replace, keep_current_best is 0.  (This state will be reset to -1 as
     * soon as we've made the replacement, but sometimes we make the choice in
     * advance of actually finding a replacement best tuple.)
     */
    keep_current_best = -1;
 
    /*
     * Loop over tuples on page.
     */
    maxoff = PageGetMaxOffsetNumber(p);
    Assert(maxoff >= FirstOffsetNumber);
 
    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
    {
        IndexTuple  itup = (IndexTuple) PageGetItem(p, PageGetItemId(p, i));
        bool        zero_penalty;
        int         j;
 
        zero_penalty = true;
 
        /* Loop over index attributes. */
        for (j = 0; j < IndexRelationGetNumberOfKeyAttributes(r); j++)
        {
            Datum       datum;
            float       usize;
            bool        IsNull;
 
            /* Compute penalty for this column. */
            datum = index_getattr(itup, j + 1, giststate->leafTupdesc,
                                  &IsNull);
            gistdentryinit(giststate, j, &entry, datum, r, p, i,
                           false, IsNull);
            usize = gistpenalty(giststate, j, &entry, IsNull,
                                &identry[j], isnull[j]);
            if (usize > 0)
                zero_penalty = false;
 
            if (best_penalty[j] < 0 || usize < best_penalty[j])
            {
                /*
                 * New best penalty for column.  Tentatively select this tuple
                 * as the target, and record the best penalty.  Then reset the
                 * next column's penalty to "unknown" (and indirectly, the
                 * same for all the ones to its right).  This will force us to
                 * adopt this tuple's penalty values as the best for all the
                 * remaining columns during subsequent loop iterations.
                 */
                result = i;
                best_penalty[j] = usize;
 
                if (j < IndexRelationGetNumberOfKeyAttributes(r) - 1)
                    best_penalty[j + 1] = -1;
 
                /* we have new best, so reset keep-it decision */
                keep_current_best = -1;
            }
            else if (best_penalty[j] == usize)
            {
                /*
                 * The current tuple is exactly as good for this column as the
                 * best tuple seen so far.  The next iteration of this loop
                 * will compare the next column.
                 */
            }
            else
            {
                /*
                 * The current tuple is worse for this column than the best
                 * tuple seen so far.  Skip the remaining columns and move on
                 * to the next tuple, if any.
                 */
                zero_penalty = false;   /* so outer loop won't exit */
                break;
            }
        }
 
        /*
         * If we looped past the last column, and did not update "result",
         * then this tuple is exactly as good as the prior best tuple.
         */
        if (j == IndexRelationGetNumberOfKeyAttributes(r) && result != i)
        {
            if (keep_current_best == -1)
            {
                /* we didn't make the random choice yet for this old best */
                keep_current_best = pg_prng_bool(&pg_global_prng_state) ? 1 : 0;
            }
            if (keep_current_best == 0)
            {
                /* we choose to use the new tuple */
                result = i;
                /* choose again if there are even more exactly-as-good ones */
                keep_current_best = -1;
            }
        }
 
        /*
         * If we find a tuple with zero penalty for all columns, and we've
         * decided we don't want to search for another tuple with equal
         * penalty, there's no need to examine remaining tuples; just break
         * out of the loop and return it.
         */
        if (zero_penalty)
        {
            if (keep_current_best == -1)
            {
                /* we didn't make the random choice yet for this old best */
                keep_current_best = pg_prng_bool(&pg_global_prng_state) ? 1 : 0;
            }
            if (keep_current_best == 1)
                break;
        }
    }
 
    return result;
}

References Assert(), FirstOffsetNumber, gistDeCompressAtt(), gistdentryinit(), GistPageIsLeaf, gistpenalty(), i, index_getattr(), INDEX_MAX_KEYS, IndexRelationGetNumberOfKeyAttributes, j, GISTSTATE::leafTupdesc, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), pg_global_prng_state, and pg_prng_bool().

Referenced by gistdoinsert(), and gistProcessItup().

gistCompressValues()

void gistCompressValues	(	GISTSTATE *	giststate,
		Relation	r,
		Datum *	attdata,
		bool *	isnull,
		bool	isleaf,
		Datum *	compatt
	)

Definition at line 596 of file gistutil.c.

{
    int         i;
 
    /*
     * Call the compress method on each attribute.
     */
    for (i = 0; i < IndexRelationGetNumberOfKeyAttributes(r); i++)
    {
        if (isnull[i])
            compatt[i] = (Datum) 0;
        else
        {
            GISTENTRY   centry;
            GISTENTRY  *cep;
 
            gistentryinit(centry, attdata[i], r, NULL, (OffsetNumber) 0,
                          isleaf);
            /* there may not be a compress function in opclass */
            if (OidIsValid(giststate->compressFn[i].fn_oid))
                cep = (GISTENTRY *)
                    DatumGetPointer(FunctionCall1Coll(&giststate->compressFn[i],
                                                      giststate->supportCollation[i],
                                                      PointerGetDatum(&centry)));
            else
                cep = &centry;
            compatt[i] = cep->key;
        }
    }
 
    if (isleaf)
    {
        /*
         * Emplace each included attribute if any.
         */
        for (; i < r->rd_att->natts; i++)
        {
            if (isnull[i])
                compatt[i] = (Datum) 0;
            else
                compatt[i] = attdata[i];
        }
    }
}

References GISTSTATE::compressFn, DatumGetPointer(), FmgrInfo::fn_oid, FunctionCall1Coll(), gistentryinit, i, IndexRelationGetNumberOfKeyAttributes, GISTENTRY::key, TupleDescData::natts, OidIsValid, PointerGetDatum(), RelationData::rd_att, and GISTSTATE::supportCollation.

Referenced by gistFormTuple(), and gistSortedBuildCallback().

gistDeCompressAtt()

void gistDeCompressAtt	(	GISTSTATE *	giststate,
		Relation	r,
		IndexTuple	tuple,
		Page	p,
		OffsetNumber	o,
		GISTENTRY *	attdata,
		bool *	isnull
	)

Definition at line 296 of file gistutil.c.

{
    int         i;
 
    for (i = 0; i < IndexRelationGetNumberOfKeyAttributes(r); i++)
    {
        Datum       datum;
 
        datum = index_getattr(tuple, i + 1, giststate->leafTupdesc, &isnull[i]);
        gistdentryinit(giststate, i, &attdata[i],
                       datum, r, p, o,
                       false, isnull[i]);
    }
}

References gistdentryinit(), i, index_getattr(), IndexRelationGetNumberOfKeyAttributes, and GISTSTATE::leafTupdesc.

Referenced by gistchoose(), gistgetadjusted(), gistRelocateBuildBuffersOnSplit(), and placeOne().

gistdentryinit()

void gistdentryinit	(	GISTSTATE *	giststate,
		int	nkey,
		GISTENTRY *	e,
		Datum	k,
		Relation	r,
		Page	pg,
		OffsetNumber	o,
		bool	l,
		bool	isNull
	)

Definition at line 547 of file gistutil.c.

{
    if (!isNull)
    {
        GISTENTRY  *dep;
 
        gistentryinit(*e, k, r, pg, o, l);
 
        /* there may not be a decompress function in opclass */
        if (!OidIsValid(giststate->decompressFn[nkey].fn_oid))
            return;
 
        dep = (GISTENTRY *)
            DatumGetPointer(FunctionCall1Coll(&giststate->decompressFn[nkey],
                                              giststate->supportCollation[nkey],
                                              PointerGetDatum(e)));
        /* decompressFn may just return the given pointer */
        if (dep != e)
            gistentryinit(*e, dep->key, dep->rel, dep->page, dep->offset,
                          dep->leafkey);
    }
    else
        gistentryinit(*e, (Datum) 0, r, pg, o, l);
}

References DatumGetPointer(), GISTSTATE::decompressFn, FmgrInfo::fn_oid, FunctionCall1Coll(), gistentryinit, GISTENTRY::key, GISTENTRY::leafkey, GISTENTRY::offset, OidIsValid, GISTENTRY::page, PointerGetDatum(), GISTENTRY::rel, and GISTSTATE::supportCollation.

Referenced by gistchoose(), gistDeCompressAtt(), gistindex_keytest(), gistMakeUnionItVec(), and gistSplitByKey().

gistextractpage()

IndexTuple* gistextractpage	(	Page	page,
		int *	len
	)

Definition at line 95 of file gistutil.c.

{
    OffsetNumber i,
                maxoff;
    IndexTuple *itvec;
 
    maxoff = PageGetMaxOffsetNumber(page);
    *len = maxoff;
    itvec = palloc(sizeof(IndexTuple) * maxoff);
    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
        itvec[i - FirstOffsetNumber] = (IndexTuple) PageGetItem(page, PageGetItemId(page, i));
 
    return itvec;
}

References FirstOffsetNumber, i, len, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), and palloc().

Referenced by gist_indexsortbuild_levelstate_flush(), and gistplacetopage().

gistFetchAtt()

static Datum gistFetchAtt ( GISTSTATE *  giststate, int  nkey, Datum  k, Relation  r  )

static

Definition at line 646 of file gistutil.c.

{
    GISTENTRY   fentry;
    GISTENTRY  *fep;
 
    gistentryinit(fentry, k, r, NULL, (OffsetNumber) 0, false);
 
    fep = (GISTENTRY *)
        DatumGetPointer(FunctionCall1Coll(&giststate->fetchFn[nkey],
                                          giststate->supportCollation[nkey],
                                          PointerGetDatum(&fentry)));
 
    /* fetchFn set 'key', return it to the caller */
    return fep->key;
}

References DatumGetPointer(), GISTSTATE::fetchFn, FunctionCall1Coll(), gistentryinit, GISTENTRY::key, PointerGetDatum(), and GISTSTATE::supportCollation.

Referenced by gistFetchTuple().

gistFetchTuple()

HeapTuple gistFetchTuple	(	GISTSTATE *	giststate,
		Relation	r,
		IndexTuple	tuple
	)

Definition at line 667 of file gistutil.c.

{
    MemoryContext oldcxt = MemoryContextSwitchTo(giststate->tempCxt);
    Datum       fetchatt[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    int         i;
 
    for (i = 0; i < IndexRelationGetNumberOfKeyAttributes(r); i++)
    {
        Datum       datum;
 
        datum = index_getattr(tuple, i + 1, giststate->leafTupdesc, &isnull[i]);
 
        if (giststate->fetchFn[i].fn_oid != InvalidOid)
        {
            if (!isnull[i])
                fetchatt[i] = gistFetchAtt(giststate, i, datum, r);
            else
                fetchatt[i] = (Datum) 0;
        }
        else if (giststate->compressFn[i].fn_oid == InvalidOid)
        {
            /*
             * If opclass does not provide compress method that could change
             * original value, att is necessarily stored in original form.
             */
            if (!isnull[i])
                fetchatt[i] = datum;
            else
                fetchatt[i] = (Datum) 0;
        }
        else
        {
            /*
             * Index-only scans not supported for this column. Since the
             * planner chose an index-only scan anyway, it is not interested
             * in this column, and we can replace it with a NULL.
             */
            isnull[i] = true;
            fetchatt[i] = (Datum) 0;
        }
    }
 
    /*
     * Get each included attribute.
     */
    for (; i < r->rd_att->natts; i++)
    {
        fetchatt[i] = index_getattr(tuple, i + 1, giststate->leafTupdesc,
                                    &isnull[i]);
    }
    MemoryContextSwitchTo(oldcxt);
 
    return heap_form_tuple(giststate->fetchTupdesc, fetchatt, isnull);
}

References GISTSTATE::compressFn, fetchatt, GISTSTATE::fetchFn, GISTSTATE::fetchTupdesc, FmgrInfo::fn_oid, gistFetchAtt(), heap_form_tuple(), i, index_getattr(), INDEX_MAX_KEYS, IndexRelationGetNumberOfKeyAttributes, InvalidOid, GISTSTATE::leafTupdesc, MemoryContextSwitchTo(), TupleDescData::natts, RelationData::rd_att, and GISTSTATE::tempCxt.

Referenced by gistScanPage().

gistfillbuffer()

void gistfillbuffer	(	Page	page,
		IndexTuple *	itup,
		int	len,
		OffsetNumber	off
	)

Definition at line 34 of file gistutil.c.

{
    int         i;
 
    if (off == InvalidOffsetNumber)
        off = (PageIsEmpty(page)) ? FirstOffsetNumber :
            OffsetNumberNext(PageGetMaxOffsetNumber(page));
 
    for (i = 0; i < len; i++)
    {
        Size        sz = IndexTupleSize(itup[i]);
        OffsetNumber l;
 
        l = PageAddItem(page, (Item) itup[i], sz, off, false, false);
        if (l == InvalidOffsetNumber)
            elog(ERROR, "failed to add item to GiST index page, item %d out of %d, size %d bytes",
                 i, len, (int) sz);
        off++;
    }
}

References elog(), ERROR, FirstOffsetNumber, i, IndexTupleSize, InvalidOffsetNumber, len, OffsetNumberNext, PageAddItem, PageGetMaxOffsetNumber(), and PageIsEmpty().

Referenced by gist_indexsortbuild_levelstate_add(), gistplacetopage(), and gistRedoPageSplitRecord().

gistfillitupvec()

IndexTupleData* gistfillitupvec	(	IndexTuple *	vec,
		int	veclen,
		int *	memlen
	)

Definition at line 127 of file gistutil.c.

{
    char       *ptr,
               *ret;
    int         i;
 
    *memlen = 0;
 
    for (i = 0; i < veclen; i++)
        *memlen += IndexTupleSize(vec[i]);
 
    ptr = ret = palloc(*memlen);
 
    for (i = 0; i < veclen; i++)
    {
        memcpy(ptr, vec[i], IndexTupleSize(vec[i]));
        ptr += IndexTupleSize(vec[i]);
    }
 
    return (IndexTupleData *) ret;
}

References i, IndexTupleSize, and palloc().

Referenced by gist_indexsortbuild_levelstate_flush(), gistplacetopage(), and gistSplit().

gistfitpage()

bool gistfitpage	(	IndexTuple *	itvec,
		int	len
	)

Definition at line 79 of file gistutil.c.

{
    int         i;
    Size        size = 0;
 
    for (i = 0; i < len; i++)
        size += IndexTupleSize(itvec[i]) + sizeof(ItemIdData);
 
    /* TODO: Consider fillfactor */
    return (size <= GiSTPageSize);
}

References GiSTPageSize, i, IndexTupleSize, and len.

Referenced by gistSplit().

gistFormTuple()

IndexTuple gistFormTuple	(	GISTSTATE *	giststate,
		Relation	r,
		Datum *	attdata,
		bool *	isnull,
		bool	isleaf
	)

Definition at line 575 of file gistutil.c.

{
    Datum       compatt[INDEX_MAX_KEYS];
    IndexTuple  res;
 
    gistCompressValues(giststate, r, attdata, isnull, isleaf, compatt);
 
    res = index_form_tuple(isleaf ? giststate->leafTupdesc :
                           giststate->nonLeafTupdesc,
                           compatt, isnull);
 
    /*
     * The offset number on tuples on internal pages is unused. For historical
     * reasons, it is set to 0xffff.
     */
    ItemPointerSetOffsetNumber(&(res->t_tid), 0xffff);
    return res;
}

References gistCompressValues(), index_form_tuple(), INDEX_MAX_KEYS, ItemPointerSetOffsetNumber(), GISTSTATE::leafTupdesc, GISTSTATE::nonLeafTupdesc, and res.

Referenced by gistBuildCallback(), gistgetadjusted(), gistinsert(), gistSplit(), and gistunion().

gistgetadjusted()

IndexTuple gistgetadjusted	(	Relation	r,
		IndexTuple	oldtup,
		IndexTuple	addtup,
		GISTSTATE *	giststate
	)

Definition at line 316 of file gistutil.c.

{
    bool        neednew = false;
    GISTENTRY   oldentries[INDEX_MAX_KEYS],
                addentries[INDEX_MAX_KEYS];
    bool        oldisnull[INDEX_MAX_KEYS],
                addisnull[INDEX_MAX_KEYS];
    Datum       attr[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    IndexTuple  newtup = NULL;
    int         i;
 
    gistDeCompressAtt(giststate, r, oldtup, NULL,
                      (OffsetNumber) 0, oldentries, oldisnull);
 
    gistDeCompressAtt(giststate, r, addtup, NULL,
                      (OffsetNumber) 0, addentries, addisnull);
 
    for (i = 0; i < IndexRelationGetNumberOfKeyAttributes(r); i++)
    {
        gistMakeUnionKey(giststate, i,
                         oldentries + i, oldisnull[i],
                         addentries + i, addisnull[i],
                         attr + i, isnull + i);
 
        if (neednew)
            /* we already need new key, so we can skip check */
            continue;
 
        if (isnull[i])
            /* union of key may be NULL if and only if both keys are NULL */
            continue;
 
        if (!addisnull[i])
        {
            if (oldisnull[i] ||
                !gistKeyIsEQ(giststate, i, oldentries[i].key, attr[i]))
                neednew = true;
        }
    }
 
    if (neednew)
    {
        /* need to update key */
        newtup = gistFormTuple(giststate, r, attr, isnull, false);
        newtup->t_tid = oldtup->t_tid;
    }
 
    return newtup;
}

References gistDeCompressAtt(), gistFormTuple(), gistKeyIsEQ(), gistMakeUnionKey(), i, INDEX_MAX_KEYS, IndexRelationGetNumberOfKeyAttributes, sort-test::key, and IndexTupleData::t_tid.

Referenced by gistdoinsert(), gistformdownlink(), gistProcessItup(), and gistRelocateBuildBuffersOnSplit().

gistGetFakeLSN()

XLogRecPtr gistGetFakeLSN

(

Relation

rel

)

Definition at line 1016 of file gistutil.c.

{
    if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
    {
        /*
         * Temporary relations are only accessible in our session, so a simple
         * backend-local counter will do.
         */
        static XLogRecPtr counter = FirstNormalUnloggedLSN;
 
        return counter++;
    }
    else if (RelationIsPermanent(rel))
    {
        /*
         * WAL-logging on this relation will start after commit, so its LSNs
         * must be distinct numbers smaller than the LSN at the next commit.
         * Emit a dummy WAL record if insert-LSN hasn't advanced after the
         * last call.
         */
        static XLogRecPtr lastlsn = InvalidXLogRecPtr;
        XLogRecPtr  currlsn = GetXLogInsertRecPtr();
 
        /* Shouldn't be called for WAL-logging relations */
        Assert(!RelationNeedsWAL(rel));
 
        /* No need for an actual record if we already have a distinct LSN */
        if (!XLogRecPtrIsInvalid(lastlsn) && lastlsn == currlsn)
            currlsn = gistXLogAssignLSN();
 
        lastlsn = currlsn;
        return currlsn;
    }
    else
    {
        /*
         * Unlogged relations are accessible from other backends, and survive
         * (clean) restarts. GetFakeLSNForUnloggedRel() handles that for us.
         */
        Assert(rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED);
        return GetFakeLSNForUnloggedRel();
    }
}

References Assert(), FirstNormalUnloggedLSN, GetFakeLSNForUnloggedRel(), GetXLogInsertRecPtr(), gistXLogAssignLSN(), InvalidXLogRecPtr, RelationData::rd_rel, RelationIsPermanent, RelationNeedsWAL, and XLogRecPtrIsInvalid.

Referenced by gistdeletepage(), gistplacetopage(), gistprunepage(), gistvacuumpage(), and gistvacuumscan().

GISTInitBuffer()

void GISTInitBuffer	(	Buffer	b,
		uint32	f
	)

Definition at line 773 of file gistutil.c.

{
    Page        page;
 
    page = BufferGetPage(b);
    gistinitpage(page, f);
}

References b, BufferGetPage(), and gistinitpage().

Referenced by gistbuild(), gistbuildempty(), gistplacetopage(), and gistRedoPageSplitRecord().

gistinitpage()

void gistinitpage	(	Page	page,
		uint32	f
	)

Definition at line 757 of file gistutil.c.

{
    GISTPageOpaque opaque;
 
    PageInit(page, BLCKSZ, sizeof(GISTPageOpaqueData));
 
    opaque = GistPageGetOpaque(page);
    opaque->rightlink = InvalidBlockNumber;
    opaque->flags = f;
    opaque->gist_page_id = GIST_PAGE_ID;
}

References GISTPageOpaqueData::flags, GISTPageOpaqueData::gist_page_id, GIST_PAGE_ID, GistPageGetOpaque, InvalidBlockNumber, PageInit(), and GISTPageOpaqueData::rightlink.

Referenced by gist_indexsortbuild(), gist_indexsortbuild_levelstate_add(), gist_indexsortbuild_levelstate_flush(), and GISTInitBuffer().

gistjoinvector()

IndexTuple* gistjoinvector	(	IndexTuple *	itvec,
		int *	len,
		IndexTuple *	additvec,
		int	addlen
	)

Definition at line 114 of file gistutil.c.

{
    itvec = (IndexTuple *) repalloc(itvec, sizeof(IndexTuple) * ((*len) + addlen));
    memmove(&itvec[*len], additvec, sizeof(IndexTuple) * addlen);
    *len += addlen;
    return itvec;
}

References len, and repalloc().

Referenced by gist_indexsortbuild_levelstate_flush(), and gistplacetopage().

gistKeyIsEQ()

bool gistKeyIsEQ	(	GISTSTATE *	giststate,
		int	attno,
		Datum	a,
		Datum	b
	)

Definition at line 281 of file gistutil.c.

{
    bool        result = false; /* silence compiler warning */
 
    FunctionCall3Coll(&giststate->equalFn[attno],
                      giststate->supportCollation[attno],
                      a, b,
                      PointerGetDatum(&result));
    return result;
}

References a, b, GISTSTATE::equalFn, FunctionCall3Coll(), PointerGetDatum(), and GISTSTATE::supportCollation.

Referenced by gistgetadjusted(), and gistUserPicksplit().

gistMakeUnionItVec()

void gistMakeUnionItVec	(	GISTSTATE *	giststate,
		IndexTuple *	itvec,
		int	len,
		Datum *	attr,
		bool *	isnull
	)

Definition at line 155 of file gistutil.c.

{
    int         i;
    GistEntryVector *evec;
    int         attrsize;
 
    evec = (GistEntryVector *) palloc((len + 2) * sizeof(GISTENTRY) + GEVHDRSZ);
 
    for (i = 0; i < giststate->nonLeafTupdesc->natts; i++)
    {
        int         j;
 
        /* Collect non-null datums for this column */
        evec->n = 0;
        for (j = 0; j < len; j++)
        {
            Datum       datum;
            bool        IsNull;
 
            datum = index_getattr(itvec[j], i + 1, giststate->leafTupdesc,
                                  &IsNull);
            if (IsNull)
                continue;
 
            gistdentryinit(giststate, i,
                           evec->vector + evec->n,
                           datum,
                           NULL, NULL, (OffsetNumber) 0,
                           false, IsNull);
            evec->n++;
        }
 
        /* If this column was all NULLs, the union is NULL */
        if (evec->n == 0)
        {
            attr[i] = (Datum) 0;
            isnull[i] = true;
        }
        else
        {
            if (evec->n == 1)
            {
                /* unionFn may expect at least two inputs */
                evec->n = 2;
                evec->vector[1] = evec->vector[0];
            }
 
            /* Make union and store in attr array */
            attr[i] = FunctionCall2Coll(&giststate->unionFn[i],
                                        giststate->supportCollation[i],
                                        PointerGetDatum(evec),
                                        PointerGetDatum(&attrsize));
 
            isnull[i] = false;
        }
    }
}

References FunctionCall2Coll(), GEVHDRSZ, gistdentryinit(), i, index_getattr(), j, GISTSTATE::leafTupdesc, len, GistEntryVector::n, TupleDescData::natts, GISTSTATE::nonLeafTupdesc, palloc(), PointerGetDatum(), GISTSTATE::supportCollation, GISTSTATE::unionFn, and GistEntryVector::vector.

Referenced by gistunion(), and gistunionsubkeyvec().

gistMakeUnionKey()

void gistMakeUnionKey	(	GISTSTATE *	giststate,
		int	attno,
		GISTENTRY *	entry1,
		bool	isnull1,
		GISTENTRY *	entry2,
		bool	isnull2,
		Datum *	dst,
		bool *	dstisnull
	)

Definition at line 233 of file gistutil.c.

{
    /* we need a GistEntryVector with room for exactly 2 elements */
    union
    {
        GistEntryVector gev;
        char        padding[2 * sizeof(GISTENTRY) + GEVHDRSZ];
    }           storage;
    GistEntryVector *evec = &storage.gev;
    int         dstsize;
 
    evec->n = 2;
 
    if (isnull1 && isnull2)
    {
        *dstisnull = true;
        *dst = (Datum) 0;
    }
    else
    {
        if (isnull1 == false && isnull2 == false)
        {
            evec->vector[0] = *entry1;
            evec->vector[1] = *entry2;
        }
        else if (isnull1 == false)
        {
            evec->vector[0] = *entry1;
            evec->vector[1] = *entry1;
        }
        else
        {
            evec->vector[0] = *entry2;
            evec->vector[1] = *entry2;
        }
 
        *dstisnull = false;
        *dst = FunctionCall2Coll(&giststate->unionFn[attno],
                                 giststate->supportCollation[attno],
                                 PointerGetDatum(evec),
                                 PointerGetDatum(&dstsize));
    }
}

References FunctionCall2Coll(), GEVHDRSZ, GistEntryVector::n, PointerGetDatum(), storage, GISTSTATE::supportCollation, GISTSTATE::unionFn, and GistEntryVector::vector.

Referenced by gistgetadjusted(), and supportSecondarySplit().

gistNewBuffer()

Buffer gistNewBuffer	(	Relation	r,
		Relation	heaprel
	)

Definition at line 824 of file gistutil.c.

{
    Buffer      buffer;
 
    /* First, try to get a page from FSM */
    for (;;)
    {
        BlockNumber blkno = GetFreeIndexPage(r);
 
        if (blkno == InvalidBlockNumber)
            break;              /* nothing left in FSM */
 
        buffer = ReadBuffer(r, blkno);
 
        /*
         * We have to guard against the possibility that someone else already
         * recycled this page; the buffer may be locked if so.
         */
        if (ConditionalLockBuffer(buffer))
        {
            Page        page = BufferGetPage(buffer);
 
            /*
             * If the page was never initialized, it's OK to use.
             */
            if (PageIsNew(page))
                return buffer;
 
            gistcheckpage(r, buffer);
 
            /*
             * Otherwise, recycle it if deleted, and too old to have any
             * processes interested in it.
             */
            if (gistPageRecyclable(page))
            {
                /*
                 * If we are generating WAL for Hot Standby then create a WAL
                 * record that will allow us to conflict with queries running
                 * on standby, in case they have snapshots older than the
                 * page's deleteXid.
                 */
                if (XLogStandbyInfoActive() && RelationNeedsWAL(r))
                    gistXLogPageReuse(r, heaprel, blkno, GistPageGetDeleteXid(page));
 
                return buffer;
            }
 
            LockBuffer(buffer, GIST_UNLOCK);
        }
 
        /* Can't use it, so release buffer and try again */
        ReleaseBuffer(buffer);
    }
 
    /* Must extend the file */
    buffer = ExtendBufferedRel(EB_REL(r), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;
}

References BufferGetPage(), ConditionalLockBuffer(), EB_LOCK_FIRST, EB_REL, ExtendBufferedRel(), GetFreeIndexPage(), GIST_UNLOCK, gistcheckpage(), GistPageGetDeleteXid(), gistPageRecyclable(), gistXLogPageReuse(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, PageIsNew(), ReadBuffer(), RelationNeedsWAL, ReleaseBuffer(), and XLogStandbyInfoActive.

Referenced by gistbuild(), and gistplacetopage().

gistnospace()

bool gistnospace	(	Page	page,
		IndexTuple *	itvec,
		int	len,
		OffsetNumber	todelete,
		Size	freespace
	)

Definition at line 59 of file gistutil.c.

{
    unsigned int size = freespace,
                deleted = 0;
    int         i;
 
    for (i = 0; i < len; i++)
        size += IndexTupleSize(itvec[i]) + sizeof(ItemIdData);
 
    if (todelete != InvalidOffsetNumber)
    {
        IndexTuple  itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, todelete));
 
        deleted = IndexTupleSize(itup) + sizeof(ItemIdData);
    }
 
    return (PageGetFreeSpace(page) + deleted < size);
}

References i, IndexTupleSize, InvalidOffsetNumber, len, PageGetFreeSpace(), PageGetItem(), and PageGetItemId().

Referenced by gistplacetopage().

gistoptions()

bytea* gistoptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 912 of file gistutil.c.

{
    static const relopt_parse_elt tab[] = {
        {"fillfactor", RELOPT_TYPE_INT, offsetof(GiSTOptions, fillfactor)},
        {"buffering", RELOPT_TYPE_ENUM, offsetof(GiSTOptions, buffering_mode)}
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_GIST,
                                      sizeof(GiSTOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), fillfactor, lengthof, RELOPT_KIND_GIST, RELOPT_TYPE_ENUM, and RELOPT_TYPE_INT.

Referenced by gisthandler().

gistPageRecyclable()

bool gistPageRecyclable

(

Page

page

)

Definition at line 888 of file gistutil.c.

{
    if (PageIsNew(page))
        return true;
    if (GistPageIsDeleted(page))
    {
        /*
         * The page was deleted, but when? If it was just deleted, a scan
         * might have seen the downlink to it, and will read the page later.
         * As long as that can happen, we must keep the deleted page around as
         * a tombstone.
         *
         * For that check if the deletion XID could still be visible to
         * anyone. If not, then no scan that's still in progress could have
         * seen its downlink, and we can recycle it.
         */
        FullTransactionId deletexid_full = GistPageGetDeleteXid(page);
 
        return GlobalVisCheckRemovableFullXid(NULL, deletexid_full);
    }
    return false;
}

References GistPageGetDeleteXid(), GistPageIsDeleted, GlobalVisCheckRemovableFullXid(), and PageIsNew().

Referenced by gistNewBuffer(), and gistvacuumpage().

gistpenalty()

float gistpenalty	(	GISTSTATE *	giststate,
		int	attno,
		GISTENTRY *	orig,
		bool	isNullOrig,
		GISTENTRY *	add,
		bool	isNullAdd
	)

Definition at line 724 of file gistutil.c.

{
    float       penalty = 0.0;
 
    if (giststate->penaltyFn[attno].fn_strict == false ||
        (isNullOrig == false && isNullAdd == false))
    {
        FunctionCall3Coll(&giststate->penaltyFn[attno],
                          giststate->supportCollation[attno],
                          PointerGetDatum(orig),
                          PointerGetDatum(add),
                          PointerGetDatum(&penalty));
        /* disallow negative or NaN penalty */
        if (isnan(penalty) || penalty < 0.0)
            penalty = 0.0;
    }
    else if (isNullOrig && isNullAdd)
        penalty = 0.0;
    else
    {
        /* try to prevent mixing null and non-null values */
        penalty = get_float4_infinity();
    }
 
    return penalty;
}

References FmgrInfo::fn_strict, FunctionCall3Coll(), get_float4_infinity(), GISTSTATE::penaltyFn, PointerGetDatum(), and GISTSTATE::supportCollation.

Referenced by findDontCares(), gistchoose(), gistRelocateBuildBuffersOnSplit(), placeOne(), and supportSecondarySplit().

gistproperty()

bool gistproperty	(	Oid	index_oid,
		int	attno,
		IndexAMProperty	prop,
		const char *	propname,
		bool *	res,
		bool *	isnull
	)

Definition at line 933 of file gistutil.c.

{
    Oid         opclass,
                opfamily,
                opcintype;
    int16       procno;
 
    /* Only answer column-level inquiries */
    if (attno == 0)
        return false;
 
    /*
     * Currently, GiST distance-ordered scans require that there be a distance
     * function in the opclass with the default types (i.e. the one loaded
     * into the relcache entry, see initGISTstate).  So we assume that if such
     * a function exists, then there's a reason for it (rather than grubbing
     * through all the opfamily's operators to find an ordered one).
     *
     * Essentially the same code can test whether we support returning the
     * column data, since that's true if the opclass provides a fetch proc.
     */
 
    switch (prop)
    {
        case AMPROP_DISTANCE_ORDERABLE:
            procno = GIST_DISTANCE_PROC;
            break;
        case AMPROP_RETURNABLE:
            procno = GIST_FETCH_PROC;
            break;
        default:
            return false;
    }
 
    /* First we need to know the column's opclass. */
    opclass = get_index_column_opclass(index_oid, attno);
    if (!OidIsValid(opclass))
    {
        *isnull = true;
        return true;
    }
 
    /* Now look up the opclass family and input datatype. */
    if (!get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
    {
        *isnull = true;
        return true;
    }
 
    /* And now we can check whether the function is provided. */
 
    *res = SearchSysCacheExists4(AMPROCNUM,
                                 ObjectIdGetDatum(opfamily),
                                 ObjectIdGetDatum(opcintype),
                                 ObjectIdGetDatum(opcintype),
                                 Int16GetDatum(procno));
 
    /*
     * Special case: even without a fetch function, AMPROP_RETURNABLE is true
     * if the opclass has no compress function.
     */
    if (prop == AMPROP_RETURNABLE && !*res)
    {
        *res = !SearchSysCacheExists4(AMPROCNUM,
                                      ObjectIdGetDatum(opfamily),
                                      ObjectIdGetDatum(opcintype),
                                      ObjectIdGetDatum(opcintype),
                                      Int16GetDatum(GIST_COMPRESS_PROC));
    }
 
    *isnull = false;
 
    return true;
}

References AMPROCNUM, AMPROP_DISTANCE_ORDERABLE, AMPROP_RETURNABLE, get_index_column_opclass(), get_opclass_opfamily_and_input_type(), GIST_COMPRESS_PROC, GIST_DISTANCE_PROC, GIST_FETCH_PROC, Int16GetDatum(), ObjectIdGetDatum(), OidIsValid, res, and SearchSysCacheExists4.

Referenced by gisthandler().

gistunion()

IndexTuple gistunion	(	Relation	r,
		IndexTuple *	itvec,
		int	len,
		GISTSTATE *	giststate
	)

Definition at line 219 of file gistutil.c.

{
    Datum       attr[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
 
    gistMakeUnionItVec(giststate, itvec, len, attr, isnull);
 
    return gistFormTuple(giststate, r, attr, isnull, false);
}

References gistFormTuple(), gistMakeUnionItVec(), INDEX_MAX_KEYS, and len.

Referenced by gist_indexsortbuild_levelstate_flush().