#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 "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:

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)

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 787 of file gistutil.c.

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

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

 {
     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.")));
 }

◆ gistchoose()

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

Definition at line 373 of file gistutil.c.

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

Referenced by gistdoinsert(), and gistProcessItup().

 {
     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 = (random() <= (MAX_RANDOM_VALUE / 2)) ? 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 = (random() <= (MAX_RANDOM_VALUE / 2)) ? 1 : 0;
             }
             if (keep_current_best == 1)
                 break;
         }
     }
 
     return result;
 }

◆ gistCompressValues()

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

Definition at line 595 of file gistutil.c.

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().

 {
     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];
         }
     }
 }

◆ gistDeCompressAtt()

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

Definition at line 295 of file gistutil.c.

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

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

 {
     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]);
     }
 }

◆ gistdentryinit()

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

Definition at line 546 of file gistutil.c.

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().

 {
     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);
 }

◆ gistextractpage()

IndexTuple* gistextractpage	(	Page	page,
		int *	len
	)

Definition at line 94 of file gistutil.c.

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

Referenced by gist_indexsortbuild_pagestate_flush(), and gistplacetopage().

 {
     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;
 }

◆ gistFetchAtt()

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

static

Definition at line 645 of file gistutil.c.

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

Referenced by gistFetchTuple().

 {
     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;
 }

◆ gistFetchTuple()

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

Definition at line 666 of file gistutil.c.

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().

 {
     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);
 }

◆ gistfillbuffer()

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

Definition at line 33 of file gistutil.c.

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

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

 {
     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++;
     }
 }

◆ gistfillitupvec()

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

Definition at line 126 of file gistutil.c.

References i, IndexTupleSize, and palloc().

Referenced by gistplacetopage(), and gistSplit().

 {
     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;
 }

◆ gistfitpage()

bool gistfitpage	(	IndexTuple *	itvec,
		int	len
	)

Definition at line 78 of file gistutil.c.

References GiSTPageSize, i, and IndexTupleSize.

Referenced by gistSplit().

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

◆ gistFormTuple()

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

Definition at line 574 of file gistutil.c.

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

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

 {
     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;
 }

◆ gistgetadjusted()

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

Definition at line 315 of file gistutil.c.

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

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

 {
     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;
 }

◆ gistGetFakeLSN()

XLogRecPtr gistGetFakeLSN ( Relation rel )

Definition at line 1027 of file gistutil.c.

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

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

 {
     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 (rel->rd_rel->relpersistence == RELPERSISTENCE_PERMANENT)
     {
         /*
          * 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();
     }
 }

◆ GISTInitBuffer()

void GISTInitBuffer	(	Buffer	b,
		uint32	f
	)

Definition at line 775 of file gistutil.c.

References BufferGetPage, gistinitpage(), and GistSortedBuildPageState::page.

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

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

◆ gistinitpage()

void gistinitpage	(	Page	page,
		uint32	f
	)

Definition at line 756 of file gistutil.c.

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

Referenced by gist_indexsortbuild(), gist_indexsortbuild_pagestate_flush(), and GISTInitBuffer().

 {
     GISTPageOpaque opaque;
     Size        pageSize = BLCKSZ;
 
     PageInit(page, pageSize, sizeof(GISTPageOpaqueData));
 
     opaque = GistPageGetOpaque(page);
     /* page was already zeroed by PageInit, so this is not needed: */
     /* memset(&(opaque->nsn), 0, sizeof(GistNSN)); */
     opaque->rightlink = InvalidBlockNumber;
     opaque->flags = f;
     opaque->gist_page_id = GIST_PAGE_ID;
 }

◆ gistjoinvector()

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

Definition at line 113 of file gistutil.c.

References repalloc().

Referenced by gistplacetopage().

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

◆ gistKeyIsEQ()

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

Definition at line 280 of file gistutil.c.

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

Referenced by gistgetadjusted(), and gistUserPicksplit().

 {
     bool        result;
 
     FunctionCall3Coll(&giststate->equalFn[attno],
                       giststate->supportCollation[attno],
                       a, b,
                       PointerGetDatum(&result));
     return result;
 }

◆ gistMakeUnionItVec()

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

Definition at line 154 of file gistutil.c.

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

Referenced by gistunion(), and gistunionsubkeyvec().

 {
     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;
         }
     }
 }

◆ gistMakeUnionKey()

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

Definition at line 232 of file gistutil.c.

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

Referenced by gistgetadjusted(), and supportSecondarySplit().

 {
     /* 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));
     }
 }

◆ gistNewBuffer()

Buffer gistNewBuffer ( Relation r )

Definition at line 826 of file gistutil.c.

References BufferGetPage, ConditionalLockBuffer(), ExclusiveLock, GetFreeIndexPage(), GIST_EXCLUSIVE, GIST_UNLOCK, gistcheckpage(), GistPageGetDeleteXid(), gistPageRecyclable(), gistXLogPageReuse(), InvalidBlockNumber, LockBuffer(), LockRelationForExtension(), P_NEW, GistSortedBuildPageState::page, PageIsNew, ReadBuffer(), RELATION_IS_LOCAL, RelationNeedsWAL, ReleaseBuffer(), UnlockRelationForExtension(), and XLogStandbyInfoActive.

Referenced by gistbuild(), and gistplacetopage().

 {
     Buffer      buffer;
     bool        needLock;
 
     /* 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, 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 */
     needLock = !RELATION_IS_LOCAL(r);
 
     if (needLock)
         LockRelationForExtension(r, ExclusiveLock);
 
     buffer = ReadBuffer(r, P_NEW);
     LockBuffer(buffer, GIST_EXCLUSIVE);
 
     if (needLock)
         UnlockRelationForExtension(r, ExclusiveLock);
 
     return buffer;
 }

◆ gistnospace()

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

Definition at line 58 of file gistutil.c.

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

Referenced by gistplacetopage().

 {
     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);
 }

◆ gistoptions()

bytea* gistoptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 923 of file gistutil.c.

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

Referenced by gisthandler().

 {
     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));
 }

◆ gistPageRecyclable()

bool gistPageRecyclable ( Page page )

Definition at line 899 of file gistutil.c.

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

Referenced by gistNewBuffer(), and gistvacuumpage().

 {
     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 GlobalVisIsRemovableFullXid(NULL, deletexid_full);
     }
     return false;
 }

◆ gistpenalty()

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

Definition at line 723 of file gistutil.c.

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

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

 {
     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;
 }

◆ gistproperty()

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

Definition at line 944 of file gistutil.c.

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, and SearchSysCacheExists4.