#include "postgres.h"
#include "access/genam.h"
#include "access/gist_private.h"
#include "access/relscan.h"
#include "lib/pairingheap.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "utils/float.h"
#include "utils/memutils.h"
#include "utils/rel.h"

Include dependency graph for gistget.c:

Functions
static void	gistkillitems (IndexScanDesc scan)

static bool	gistindex_keytest (IndexScanDesc scan, IndexTuple tuple, Page page, OffsetNumber offset, bool recheck_p, bool recheck_distances_p)

static void	gistScanPage (IndexScanDesc scan, GISTSearchItem pageItem, IndexOrderByDistance myDistances, TIDBitmap tbm, int64 ntids)

static GISTSearchItem *	getNextGISTSearchItem (GISTScanOpaque so)

static bool	getNextNearest (IndexScanDesc scan)

bool	gistgettuple (IndexScanDesc scan, ScanDirection dir)

int64	gistgetbitmap (IndexScanDesc scan, TIDBitmap *tbm)

bool	gistcanreturn (Relation index, int attno)

Function Documentation

◆ getNextGISTSearchItem()

static GISTSearchItem* getNextGISTSearchItem ( GISTScanOpaque so )

static

Definition at line 539 of file gistget.c.

 {
     GISTSearchItem *item;
  
     if (!pairingheap_is_empty(so->queue))
     {
         item = (GISTSearchItem *) pairingheap_remove_first(so->queue);
     }
     else
     {
         /* Done when both heaps are empty */
         item = NULL;
     }
  
     /* Return item; caller is responsible to pfree it */
     return item;
 }

References pairingheap_is_empty, pairingheap_remove_first(), and GISTScanOpaqueData::queue.

Referenced by getNextNearest(), gistgetbitmap(), and gistgettuple().

◆ getNextNearest()

static bool getNextNearest ( IndexScanDesc scan )

static

Definition at line 561 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
     bool        res = false;
  
     if (scan->xs_hitup)
     {
         /* free previously returned tuple */
         pfree(scan->xs_hitup);
         scan->xs_hitup = NULL;
     }
  
     do
     {
         GISTSearchItem *item = getNextGISTSearchItem(so);
  
         if (!item)
             break;
  
         if (GISTSearchItemIsHeap(*item))
         {
             /* found a heap item at currently minimal distance */
             scan->xs_heaptid = item->data.heap.heapPtr;
             scan->xs_recheck = item->data.heap.recheck;
  
             index_store_float8_orderby_distances(scan, so->orderByTypes,
                                                  item->distances,
                                                  item->data.heap.recheckDistances);
  
             /* in an index-only scan, also return the reconstructed tuple. */
             if (scan->xs_want_itup)
                 scan->xs_hitup = item->data.heap.recontup;
             res = true;
         }
         else
         {
             /* visit an index page, extract its items into queue */
             CHECK_FOR_INTERRUPTS();
  
             gistScanPage(scan, item, item->distances, NULL, NULL);
         }
  
         pfree(item);
     } while (!res);
  
     return res;
 }

References CHECK_FOR_INTERRUPTS, GISTSearchItem::data, GISTSearchItem::distances, getNextGISTSearchItem(), gistScanPage(), GISTSearchItemIsHeap, GISTSearchItem::heap, GISTSearchHeapItem::heapPtr, if(), index_store_float8_orderby_distances(), IndexScanDescData::opaque, GISTScanOpaqueData::orderByTypes, pfree(), GISTSearchHeapItem::recheck, GISTSearchHeapItem::recheckDistances, GISTSearchHeapItem::recontup, res, IndexScanDescData::xs_heaptid, IndexScanDescData::xs_hitup, IndexScanDescData::xs_recheck, and IndexScanDescData::xs_want_itup.

Referenced by gistgettuple().

◆ gistcanreturn()

bool gistcanreturn	(	Relation	index,
		int	attno
	)

Definition at line 794 of file gistget.c.

 {
     if (attno > IndexRelationGetNumberOfKeyAttributes(index) ||
         OidIsValid(index_getprocid(index, attno, GIST_FETCH_PROC)) ||
         !OidIsValid(index_getprocid(index, attno, GIST_COMPRESS_PROC)))
         return true;
     else
         return false;
 }

References GIST_COMPRESS_PROC, GIST_FETCH_PROC, index_getprocid(), IndexRelationGetNumberOfKeyAttributes, and OidIsValid.

Referenced by gisthandler().

◆ gistgetbitmap()

int64 gistgetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

Definition at line 744 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
     int64       ntids = 0;
     GISTSearchItem fakeItem;
  
     if (!so->qual_ok)
         return 0;
  
     pgstat_count_index_scan(scan->indexRelation);
  
     /* Begin the scan by processing the root page */
     so->curPageData = so->nPageData = 0;
     scan->xs_hitup = NULL;
     if (so->pageDataCxt)
         MemoryContextReset(so->pageDataCxt);
  
     fakeItem.blkno = GIST_ROOT_BLKNO;
     memset(&fakeItem.data.parentlsn, 0, sizeof(GistNSN));
     gistScanPage(scan, &fakeItem, NULL, tbm, &ntids);
  
     /*
      * While scanning a leaf page, ItemPointers of matching heap tuples will
      * be stored directly into tbm, so we don't need to deal with them here.
      */
     for (;;)
     {
         GISTSearchItem *item = getNextGISTSearchItem(so);
  
         if (!item)
             break;
  
         CHECK_FOR_INTERRUPTS();
  
         gistScanPage(scan, item, item->distances, tbm, &ntids);
  
         pfree(item);
     }
  
     return ntids;
 }

References CHECK_FOR_INTERRUPTS, GISTScanOpaqueData::curPageData, GISTSearchItem::distances, getNextGISTSearchItem(), GIST_ROOT_BLKNO, gistScanPage(), if(), IndexScanDescData::indexRelation, MemoryContextReset(), GISTScanOpaqueData::nPageData, IndexScanDescData::opaque, GISTScanOpaqueData::pageDataCxt, pfree(), pgstat_count_index_scan, GISTScanOpaqueData::qual_ok, and IndexScanDescData::xs_hitup.

Referenced by gisthandler().

◆ gistgettuple()

bool gistgettuple	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

Definition at line 613 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
  
     if (dir != ForwardScanDirection)
         elog(ERROR, "GiST only supports forward scan direction");
  
     if (!so->qual_ok)
         return false;
  
     if (so->firstCall)
     {
         /* Begin the scan by processing the root page */
         GISTSearchItem fakeItem;
  
         pgstat_count_index_scan(scan->indexRelation);
  
         so->firstCall = false;
         so->curPageData = so->nPageData = 0;
         scan->xs_hitup = NULL;
         if (so->pageDataCxt)
             MemoryContextReset(so->pageDataCxt);
  
         fakeItem.blkno = GIST_ROOT_BLKNO;
         memset(&fakeItem.data.parentlsn, 0, sizeof(GistNSN));
         gistScanPage(scan, &fakeItem, NULL, NULL, NULL);
     }
  
     if (scan->numberOfOrderBys > 0)
     {
         /* Must fetch tuples in strict distance order */
         return getNextNearest(scan);
     }
     else
     {
         /* Fetch tuples index-page-at-a-time */
         for (;;)
         {
             if (so->curPageData < so->nPageData)
             {
                 if (scan->kill_prior_tuple && so->curPageData > 0)
                 {
  
                     if (so->killedItems == NULL)
                     {
                         MemoryContext oldCxt =
                             MemoryContextSwitchTo(so->giststate->scanCxt);
  
                         so->killedItems =
                             (OffsetNumber *) palloc(MaxIndexTuplesPerPage
                                                     * sizeof(OffsetNumber));
  
                         MemoryContextSwitchTo(oldCxt);
                     }
                     if (so->numKilled < MaxIndexTuplesPerPage)
                         so->killedItems[so->numKilled++] =
                             so->pageData[so->curPageData - 1].offnum;
                 }
                 /* continuing to return tuples from a leaf page */
                 scan->xs_heaptid = so->pageData[so->curPageData].heapPtr;
                 scan->xs_recheck = so->pageData[so->curPageData].recheck;
  
                 /* in an index-only scan, also return the reconstructed tuple */
                 if (scan->xs_want_itup)
                     scan->xs_hitup = so->pageData[so->curPageData].recontup;
  
                 so->curPageData++;
  
                 return true;
             }
  
             /*
              * Check the last returned tuple and add it to killedItems if
              * necessary
              */
             if (scan->kill_prior_tuple
                 && so->curPageData > 0
                 && so->curPageData == so->nPageData)
             {
  
                 if (so->killedItems == NULL)
                 {
                     MemoryContext oldCxt =
                         MemoryContextSwitchTo(so->giststate->scanCxt);
  
                     so->killedItems =
                         (OffsetNumber *) palloc(MaxIndexTuplesPerPage
                                                 * sizeof(OffsetNumber));
  
                     MemoryContextSwitchTo(oldCxt);
                 }
                 if (so->numKilled < MaxIndexTuplesPerPage)
                     so->killedItems[so->numKilled++] =
                         so->pageData[so->curPageData - 1].offnum;
             }
             /* find and process the next index page */
             do
             {
                 GISTSearchItem *item;
  
                 if ((so->curBlkno != InvalidBlockNumber) && (so->numKilled > 0))
                     gistkillitems(scan);
  
                 item = getNextGISTSearchItem(so);
  
                 if (!item)
                     return false;
  
                 CHECK_FOR_INTERRUPTS();
  
                 /* save current item BlockNumber for next gistkillitems() call */
                 so->curBlkno = item->blkno;
  
                 /*
                  * While scanning a leaf page, ItemPointers of matching heap
                  * tuples are stored in so->pageData.  If there are any on
                  * this page, we fall out of the inner "do" and loop around to
                  * return them.
                  */
                 gistScanPage(scan, item, item->distances, NULL, NULL);
  
                 pfree(item);
             } while (so->nPageData == 0);
         }
     }
 }

Referenced by gisthandler().

◆ gistindex_keytest()

static bool gistindex_keytest	(	IndexScanDesc	scan,
		IndexTuple	tuple,
		Page	page,
		OffsetNumber	offset,
		bool *	recheck_p,
		bool *	recheck_distances_p
	)

static

Definition at line 126 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
     GISTSTATE  *giststate = so->giststate;
     ScanKey     key = scan->keyData;
     int         keySize = scan->numberOfKeys;
     IndexOrderByDistance *distance_p;
     Relation    r = scan->indexRelation;
  
     *recheck_p = false;
     *recheck_distances_p = false;
  
     /*
      * If it's a leftover invalid tuple from pre-9.1, treat it as a match with
      * minimum possible distances.  This means we'll always follow it to the
      * referenced page.
      */
     if (GistTupleIsInvalid(tuple))
     {
         int         i;
  
         if (GistPageIsLeaf(page))   /* shouldn't happen */
             elog(ERROR, "invalid GiST tuple found on leaf page");
         for (i = 0; i < scan->numberOfOrderBys; i++)
         {
             so->distances[i].value = -get_float8_infinity();
             so->distances[i].isnull = false;
         }
         return true;
     }
  
     /* Check whether it matches according to the Consistent functions */
     while (keySize > 0)
     {
         Datum       datum;
         bool        isNull;
  
         datum = index_getattr(tuple,
                               key->sk_attno,
                               giststate->leafTupdesc,
                               &isNull);
  
         if (key->sk_flags & SK_ISNULL)
         {
             /*
              * On non-leaf page we can't conclude that child hasn't NULL
              * values because of assumption in GiST: union (VAL, NULL) is VAL.
              * But if on non-leaf page key IS NULL, then all children are
              * NULL.
              */
             if (key->sk_flags & SK_SEARCHNULL)
             {
                 if (GistPageIsLeaf(page) && !isNull)
                     return false;
             }
             else
             {
                 Assert(key->sk_flags & SK_SEARCHNOTNULL);
                 if (isNull)
                     return false;
             }
         }
         else if (isNull)
         {
             return false;
         }
         else
         {
             Datum       test;
             bool        recheck;
             GISTENTRY   de;
  
             gistdentryinit(giststate, key->sk_attno - 1, &de,
                            datum, r, page, offset,
                            false, isNull);
  
             /*
              * Call the Consistent function to evaluate the test.  The
              * arguments are the index datum (as a GISTENTRY*), the comparison
              * datum, the comparison operator's strategy number and subtype
              * from pg_amop, and the recheck flag.
              *
              * (Presently there's no need to pass the subtype since it'll
              * always be zero, but might as well pass it for possible future
              * use.)
              *
              * We initialize the recheck flag to true (the safest assumption)
              * in case the Consistent function forgets to set it.
              */
             recheck = true;
  
             test = FunctionCall5Coll(&key->sk_func,
                                      key->sk_collation,
                                      PointerGetDatum(&de),
                                      key->sk_argument,
                                      Int16GetDatum(key->sk_strategy),
                                      ObjectIdGetDatum(key->sk_subtype),
                                      PointerGetDatum(&recheck));
  
             if (!DatumGetBool(test))
                 return false;
             *recheck_p |= recheck;
         }
  
         key++;
         keySize--;
     }
  
     /* OK, it passes --- now let's compute the distances */
     key = scan->orderByData;
     distance_p = so->distances;
     keySize = scan->numberOfOrderBys;
     while (keySize > 0)
     {
         Datum       datum;
         bool        isNull;
  
         datum = index_getattr(tuple,
                               key->sk_attno,
                               giststate->leafTupdesc,
                               &isNull);
  
         if ((key->sk_flags & SK_ISNULL) || isNull)
         {
             /* Assume distance computes as null */
             distance_p->value = 0.0;
             distance_p->isnull = true;
         }
         else
         {
             Datum       dist;
             bool        recheck;
             GISTENTRY   de;
  
             gistdentryinit(giststate, key->sk_attno - 1, &de,
                            datum, r, page, offset,
                            false, isNull);
  
             /*
              * Call the Distance function to evaluate the distance.  The
              * arguments are the index datum (as a GISTENTRY*), the comparison
              * datum, the ordering operator's strategy number and subtype from
              * pg_amop, and the recheck flag.
              *
              * (Presently there's no need to pass the subtype since it'll
              * always be zero, but might as well pass it for possible future
              * use.)
              *
              * If the function sets the recheck flag, the returned distance is
              * a lower bound on the true distance and needs to be rechecked.
              * We initialize the flag to 'false'.  This flag was added in
              * version 9.5; distance functions written before that won't know
              * about the flag, but are expected to never be lossy.
              */
             recheck = false;
             dist = FunctionCall5Coll(&key->sk_func,
                                      key->sk_collation,
                                      PointerGetDatum(&de),
                                      key->sk_argument,
                                      Int16GetDatum(key->sk_strategy),
                                      ObjectIdGetDatum(key->sk_subtype),
                                      PointerGetDatum(&recheck));
             *recheck_distances_p |= recheck;
             distance_p->value = DatumGetFloat8(dist);
             distance_p->isnull = false;
         }
  
         key++;
         distance_p++;
         keySize--;
     }
  
     return true;
 }

References Assert(), DatumGetBool(), DatumGetFloat8(), GISTScanOpaqueData::distances, elog(), ERROR, FunctionCall5Coll(), get_float8_infinity(), gistdentryinit(), GistPageIsLeaf, GISTScanOpaqueData::giststate, GistTupleIsInvalid, i, if(), index_getattr(), IndexScanDescData::indexRelation, Int16GetDatum(), IndexOrderByDistance::isnull, sort-test::key, IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, IndexScanDescData::numberOfOrderBys, ObjectIdGetDatum(), IndexScanDescData::opaque, IndexScanDescData::orderByData, PointerGetDatum(), SK_ISNULL, SK_SEARCHNOTNULL, SK_SEARCHNULL, test(), and IndexOrderByDistance::value.

Referenced by gistScanPage().

◆ gistkillitems()

static void gistkillitems ( IndexScanDesc scan )

static

Definition at line 39 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
     Buffer      buffer;
     Page        page;
     OffsetNumber offnum;
     ItemId      iid;
     int         i;
     bool        killedsomething = false;
  
     Assert(so->curBlkno != InvalidBlockNumber);
     Assert(!XLogRecPtrIsInvalid(so->curPageLSN));
     Assert(so->killedItems != NULL);
  
     buffer = ReadBuffer(scan->indexRelation, so->curBlkno);
     if (!BufferIsValid(buffer))
         return;
  
     LockBuffer(buffer, GIST_SHARE);
     gistcheckpage(scan->indexRelation, buffer);
     page = BufferGetPage(buffer);
  
     /*
      * If page LSN differs it means that the page was modified since the last
      * read. killedItems could be not valid so LP_DEAD hints applying is not
      * safe.
      */
     if (BufferGetLSNAtomic(buffer) != so->curPageLSN)
     {
         UnlockReleaseBuffer(buffer);
         so->numKilled = 0;      /* reset counter */
         return;
     }
  
     Assert(GistPageIsLeaf(page));
  
     /*
      * Mark all killedItems as dead. We need no additional recheck, because,
      * if page was modified, curPageLSN must have changed.
      */
     for (i = 0; i < so->numKilled; i++)
     {
         offnum = so->killedItems[i];
         iid = PageGetItemId(page, offnum);
         ItemIdMarkDead(iid);
         killedsomething = true;
     }
  
     if (killedsomething)
     {
         GistMarkPageHasGarbage(page);
         MarkBufferDirtyHint(buffer, true);
     }
  
     UnlockReleaseBuffer(buffer);
  
     /*
      * Always reset the scan state, so we don't look for same items on other
      * pages.
      */
     so->numKilled = 0;
 }

References Assert(), BufferGetLSNAtomic(), BufferGetPage(), BufferIsValid(), GISTScanOpaqueData::curBlkno, GISTScanOpaqueData::curPageLSN, GIST_SHARE, gistcheckpage(), GistMarkPageHasGarbage, GistPageIsLeaf, i, IndexScanDescData::indexRelation, InvalidBlockNumber, ItemIdMarkDead, GISTScanOpaqueData::killedItems, LockBuffer(), MarkBufferDirtyHint(), GISTScanOpaqueData::numKilled, IndexScanDescData::opaque, PageGetItemId(), ReadBuffer(), UnlockReleaseBuffer(), and XLogRecPtrIsInvalid.

Referenced by gistgettuple().

◆ gistScanPage()

static void gistScanPage	(	IndexScanDesc	scan,
		GISTSearchItem *	pageItem,
		IndexOrderByDistance *	myDistances,
		TIDBitmap *	tbm,
		int64 *	ntids
	)

static

Definition at line 329 of file gistget.c.

 {
     GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
     GISTSTATE  *giststate = so->giststate;
     Relation    r = scan->indexRelation;
     Buffer      buffer;
     Page        page;
     GISTPageOpaque opaque;
     OffsetNumber maxoff;
     OffsetNumber i;
     MemoryContext oldcxt;
  
     Assert(!GISTSearchItemIsHeap(*pageItem));
  
     buffer = ReadBuffer(scan->indexRelation, pageItem->blkno);
     LockBuffer(buffer, GIST_SHARE);
     PredicateLockPage(r, BufferGetBlockNumber(buffer), scan->xs_snapshot);
     gistcheckpage(scan->indexRelation, buffer);
     page = BufferGetPage(buffer);
     opaque = GistPageGetOpaque(page);
  
     /*
      * Check if we need to follow the rightlink. We need to follow it if the
      * page was concurrently split since we visited the parent (in which case
      * parentlsn < nsn), or if the system crashed after a page split but
      * before the downlink was inserted into the parent.
      */
     if (!XLogRecPtrIsInvalid(pageItem->data.parentlsn) &&
         (GistFollowRight(page) ||
          pageItem->data.parentlsn < GistPageGetNSN(page)) &&
         opaque->rightlink != InvalidBlockNumber /* sanity check */ )
     {
         /* There was a page split, follow right link to add pages */
         GISTSearchItem *item;
  
         /* This can't happen when starting at the root */
         Assert(myDistances != NULL);
  
         oldcxt = MemoryContextSwitchTo(so->queueCxt);
  
         /* Create new GISTSearchItem for the right sibling index page */
         item = palloc(SizeOfGISTSearchItem(scan->numberOfOrderBys));
         item->blkno = opaque->rightlink;
         item->data.parentlsn = pageItem->data.parentlsn;
  
         /* Insert it into the queue using same distances as for this page */
         memcpy(item->distances, myDistances,
                sizeof(item->distances[0]) * scan->numberOfOrderBys);
  
         pairingheap_add(so->queue, &item->phNode);
  
         MemoryContextSwitchTo(oldcxt);
     }
  
     /*
      * Check if the page was deleted after we saw the downlink. There's
      * nothing of interest on a deleted page. Note that we must do this after
      * checking the NSN for concurrent splits! It's possible that the page
      * originally contained some tuples that are visible to us, but was split
      * so that all the visible tuples were moved to another page, and then
      * this page was deleted.
      */
     if (GistPageIsDeleted(page))
     {
         UnlockReleaseBuffer(buffer);
         return;
     }
  
     so->nPageData = so->curPageData = 0;
     scan->xs_hitup = NULL;      /* might point into pageDataCxt */
     if (so->pageDataCxt)
         MemoryContextReset(so->pageDataCxt);
  
     /*
      * We save the LSN of the page as we read it, so that we know whether it
      * safe to apply LP_DEAD hints to the page later. This allows us to drop
      * the pin for MVCC scans, which allows vacuum to avoid blocking.
      */
     so->curPageLSN = BufferGetLSNAtomic(buffer);
  
     /*
      * check all tuples on page
      */
     maxoff = PageGetMaxOffsetNumber(page);
     for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
     {
         ItemId      iid = PageGetItemId(page, i);
         IndexTuple  it;
         bool        match;
         bool        recheck;
         bool        recheck_distances;
  
         /*
          * If the scan specifies not to return killed tuples, then we treat a
          * killed tuple as not passing the qual.
          */
         if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
             continue;
  
         it = (IndexTuple) PageGetItem(page, iid);
  
         /*
          * Must call gistindex_keytest in tempCxt, and clean up any leftover
          * junk afterward.
          */
         oldcxt = MemoryContextSwitchTo(so->giststate->tempCxt);
  
         match = gistindex_keytest(scan, it, page, i,
                                   &recheck, &recheck_distances);
  
         MemoryContextSwitchTo(oldcxt);
         MemoryContextReset(so->giststate->tempCxt);
  
         /* Ignore tuple if it doesn't match */
         if (!match)
             continue;
  
         if (tbm && GistPageIsLeaf(page))
         {
             /*
              * getbitmap scan, so just push heap tuple TIDs into the bitmap
              * without worrying about ordering
              */
             tbm_add_tuples(tbm, &it->t_tid, 1, recheck);
             (*ntids)++;
         }
         else if (scan->numberOfOrderBys == 0 && GistPageIsLeaf(page))
         {
             /*
              * Non-ordered scan, so report tuples in so->pageData[]
              */
             so->pageData[so->nPageData].heapPtr = it->t_tid;
             so->pageData[so->nPageData].recheck = recheck;
             so->pageData[so->nPageData].offnum = i;
  
             /*
              * In an index-only scan, also fetch the data from the tuple.  The
              * reconstructed tuples are stored in pageDataCxt.
              */
             if (scan->xs_want_itup)
             {
                 oldcxt = MemoryContextSwitchTo(so->pageDataCxt);
                 so->pageData[so->nPageData].recontup =
                     gistFetchTuple(giststate, r, it);
                 MemoryContextSwitchTo(oldcxt);
             }
             so->nPageData++;
         }
         else
         {
             /*
              * Must push item into search queue.  We get here for any lower
              * index page, and also for heap tuples if doing an ordered
              * search.
              */
             GISTSearchItem *item;
             int         nOrderBys = scan->numberOfOrderBys;
  
             oldcxt = MemoryContextSwitchTo(so->queueCxt);
  
             /* Create new GISTSearchItem for this item */
             item = palloc(SizeOfGISTSearchItem(scan->numberOfOrderBys));
  
             if (GistPageIsLeaf(page))
             {
                 /* Creating heap-tuple GISTSearchItem */
                 item->blkno = InvalidBlockNumber;
                 item->data.heap.heapPtr = it->t_tid;
                 item->data.heap.recheck = recheck;
                 item->data.heap.recheckDistances = recheck_distances;
  
                 /*
                  * In an index-only scan, also fetch the data from the tuple.
                  */
                 if (scan->xs_want_itup)
                     item->data.heap.recontup = gistFetchTuple(giststate, r, it);
             }
             else
             {
                 /* Creating index-page GISTSearchItem */
                 item->blkno = ItemPointerGetBlockNumber(&it->t_tid);
  
                 /*
                  * LSN of current page is lsn of parent page for child. We
                  * only have a shared lock, so we need to get the LSN
                  * atomically.
                  */
                 item->data.parentlsn = BufferGetLSNAtomic(buffer);
             }
  
             /* Insert it into the queue using new distance data */
             memcpy(item->distances, so->distances,
                    sizeof(item->distances[0]) * nOrderBys);
  
             pairingheap_add(so->queue, &item->phNode);
  
             MemoryContextSwitchTo(oldcxt);
         }
     }
  
     UnlockReleaseBuffer(buffer);
 }

Referenced by getNextNearest(), gistgetbitmap(), and gistgettuple().

Functions

Function Documentation

◆ getNextGISTSearchItem()

◆ getNextNearest()

◆ gistcanreturn()

◆ gistgetbitmap()

◆ gistgettuple()

◆ gistindex_keytest()

◆ gistkillitems()

◆ gistScanPage()