PostgreSQL Source Code  git master
gistbuild.c File Reference
#include "postgres.h"
#include <math.h>
#include "access/genam.h"
#include "access/gist_private.h"
#include "access/tableam.h"
#include "access/xloginsert.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "optimizer/optimizer.h"
#include "storage/bufmgr.h"
#include "storage/bulk_write.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/tuplesort.h"
Include dependency graph for gistbuild.c:

Go to the source code of this file.

Data Structures

struct  GISTBuildState
 
struct  GistSortedBuildLevelState
 
struct  ParentMapEntry
 

Macros

#define BUFFERING_MODE_SWITCH_CHECK_STEP   256
 
#define BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET   4096
 
#define GIST_SORTED_BUILD_PAGE_NUM   4
 

Typedefs

typedef struct GistSortedBuildLevelState GistSortedBuildLevelState
 

Enumerations

enum  GistBuildMode {
  GIST_SORTED_BUILD , GIST_BUFFERING_DISABLED , GIST_BUFFERING_AUTO , GIST_BUFFERING_STATS ,
  GIST_BUFFERING_ACTIVE
}
 

Functions

static void gistSortedBuildCallback (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
 
static void gist_indexsortbuild (GISTBuildState *state)
 
static void gist_indexsortbuild_levelstate_add (GISTBuildState *state, GistSortedBuildLevelState *levelstate, IndexTuple itup)
 
static void gist_indexsortbuild_levelstate_flush (GISTBuildState *state, GistSortedBuildLevelState *levelstate)
 
static void gistInitBuffering (GISTBuildState *buildstate)
 
static int calculatePagesPerBuffer (GISTBuildState *buildstate, int levelStep)
 
static void gistBuildCallback (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
 
static void gistBufferingBuildInsert (GISTBuildState *buildstate, IndexTuple itup)
 
static bool gistProcessItup (GISTBuildState *buildstate, IndexTuple itup, BlockNumber startblkno, int startlevel)
 
static BlockNumber gistbufferinginserttuples (GISTBuildState *buildstate, Buffer buffer, int level, IndexTuple *itup, int ntup, OffsetNumber oldoffnum, BlockNumber parentblk, OffsetNumber downlinkoffnum)
 
static Buffer gistBufferingFindCorrectParent (GISTBuildState *buildstate, BlockNumber childblkno, int level, BlockNumber *parentblkno, OffsetNumber *downlinkoffnum)
 
static void gistProcessEmptyingQueue (GISTBuildState *buildstate)
 
static void gistEmptyAllBuffers (GISTBuildState *buildstate)
 
static int gistGetMaxLevel (Relation index)
 
static void gistInitParentMap (GISTBuildState *buildstate)
 
static void gistMemorizeParent (GISTBuildState *buildstate, BlockNumber child, BlockNumber parent)
 
static void gistMemorizeAllDownlinks (GISTBuildState *buildstate, Buffer parentbuf)
 
static BlockNumber gistGetParent (GISTBuildState *buildstate, BlockNumber child)
 
IndexBuildResultgistbuild (Relation heap, Relation index, IndexInfo *indexInfo)
 

Macro Definition Documentation

◆ BUFFERING_MODE_SWITCH_CHECK_STEP

#define BUFFERING_MODE_SWITCH_CHECK_STEP   256

Definition at line 52 of file gistbuild.c.

◆ BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET

#define BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET   4096

Definition at line 60 of file gistbuild.c.

◆ GIST_SORTED_BUILD_PAGE_NUM

#define GIST_SORTED_BUILD_PAGE_NUM   4

Definition at line 113 of file gistbuild.c.

Typedef Documentation

◆ GistSortedBuildLevelState

Enumeration Type Documentation

◆ GistBuildMode

Enumerator
GIST_SORTED_BUILD 
GIST_BUFFERING_DISABLED 
GIST_BUFFERING_AUTO 
GIST_BUFFERING_STATS 
GIST_BUFFERING_ACTIVE 

Definition at line 67 of file gistbuild.c.

68 {
69  GIST_SORTED_BUILD, /* bottom-up build by sorting */
70  GIST_BUFFERING_DISABLED, /* in regular build mode and aren't going to
71  * switch */
72  GIST_BUFFERING_AUTO, /* in regular build mode, but will switch to
73  * buffering build mode if the index grows too
74  * big */
75  GIST_BUFFERING_STATS, /* gathering statistics of index tuple size
76  * before switching to the buffering build
77  * mode */
78  GIST_BUFFERING_ACTIVE, /* in buffering build mode */
GistBuildMode
Definition: gistbuild.c:68
@ GIST_BUFFERING_AUTO
Definition: gistbuild.c:72
@ GIST_SORTED_BUILD
Definition: gistbuild.c:69
@ GIST_BUFFERING_ACTIVE
Definition: gistbuild.c:78
@ GIST_BUFFERING_STATS
Definition: gistbuild.c:75
@ GIST_BUFFERING_DISABLED
Definition: gistbuild.c:70

Function Documentation

◆ calculatePagesPerBuffer()

static int calculatePagesPerBuffer ( GISTBuildState buildstate,
int  levelStep 
)
static

Definition at line 787 of file gistbuild.c.

788 {
789  double pagesPerBuffer;
790  double avgIndexTuplesPerPage;
791  double itupAvgSize;
792  Size pageFreeSpace;
793 
794  /* Calc space of index page which is available for index tuples */
795  pageFreeSpace = BLCKSZ - SizeOfPageHeaderData - sizeof(GISTPageOpaqueData)
796  - sizeof(ItemIdData)
797  - buildstate->freespace;
798 
799  /*
800  * Calculate average size of already inserted index tuples using gathered
801  * statistics.
802  */
803  itupAvgSize = (double) buildstate->indtuplesSize /
804  (double) buildstate->indtuples;
805 
806  avgIndexTuplesPerPage = pageFreeSpace / itupAvgSize;
807 
808  /*
809  * Recalculate required size of buffers.
810  */
811  pagesPerBuffer = 2 * pow(avgIndexTuplesPerPage, levelStep);
812 
813  return (int) rint(pagesPerBuffer);
814 }
#define SizeOfPageHeaderData
Definition: bufpage.h:213
size_t Size
Definition: c.h:605
struct GISTPageOpaqueData GISTPageOpaqueData
int64 indtuples
Definition: gistbuild.c:92
Size freespace
Definition: gistbuild.c:88
int64 indtuplesSize
Definition: gistbuild.c:99

References GISTBuildState::freespace, GISTBuildState::indtuples, GISTBuildState::indtuplesSize, and SizeOfPageHeaderData.

Referenced by gistBuildCallback(), and gistInitBuffering().

◆ gist_indexsortbuild()

static void gist_indexsortbuild ( GISTBuildState state)
static

Definition at line 400 of file gistbuild.c.

401 {
402  IndexTuple itup;
403  GistSortedBuildLevelState *levelstate;
404  BulkWriteBuffer rootbuf;
405 
406  /* Reserve block 0 for the root page */
407  state->pages_allocated = 1;
408 
409  state->bulkstate = smgr_bulk_start_rel(state->indexrel, MAIN_FORKNUM);
410 
411  /* Allocate a temporary buffer for the first leaf page batch. */
412  levelstate = palloc0(sizeof(GistSortedBuildLevelState));
413  levelstate->pages[0] = palloc(BLCKSZ);
414  levelstate->parent = NULL;
415  gistinitpage(levelstate->pages[0], F_LEAF);
416 
417  /*
418  * Fill index pages with tuples in the sorted order.
419  */
420  while ((itup = tuplesort_getindextuple(state->sortstate, true)) != NULL)
421  {
422  gist_indexsortbuild_levelstate_add(state, levelstate, itup);
423  MemoryContextReset(state->giststate->tempCxt);
424  }
425 
426  /*
427  * Write out the partially full non-root pages.
428  *
429  * Keep in mind that flush can build a new root. If number of pages is > 1
430  * then new root is required.
431  */
432  while (levelstate->parent != NULL || levelstate->current_page != 0)
433  {
435 
437  parent = levelstate->parent;
438  for (int i = 0; i < GIST_SORTED_BUILD_PAGE_NUM; i++)
439  if (levelstate->pages[i])
440  pfree(levelstate->pages[i]);
441  pfree(levelstate);
442  levelstate = parent;
443  }
444 
445  /* Write out the root */
446  PageSetLSN(levelstate->pages[0], GistBuildLSN);
447  rootbuf = smgr_bulk_get_buf(state->bulkstate);
448  memcpy(rootbuf, levelstate->pages[0], BLCKSZ);
449  smgr_bulk_write(state->bulkstate, GIST_ROOT_BLKNO, rootbuf, true);
450 
451  pfree(levelstate);
452 
453  smgr_bulk_finish(state->bulkstate);
454 }
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:388
void smgr_bulk_write(BulkWriteState *bulkstate, BlockNumber blocknum, BulkWriteBuffer buf, bool page_std)
Definition: bulk_write.c:271
BulkWriteBuffer smgr_bulk_get_buf(BulkWriteState *bulkstate)
Definition: bulk_write.c:295
void smgr_bulk_finish(BulkWriteState *bulkstate)
Definition: bulk_write.c:129
BulkWriteState * smgr_bulk_start_rel(Relation rel, ForkNumber forknum)
Definition: bulk_write.c:86
#define F_LEAF
Definition: gist.h:46
#define GistBuildLSN
Definition: gist.h:67
#define GIST_ROOT_BLKNO
Definition: gist_private.h:262
static void gist_indexsortbuild_levelstate_flush(GISTBuildState *state, GistSortedBuildLevelState *levelstate)
Definition: gistbuild.c:493
static void gist_indexsortbuild_levelstate_add(GISTBuildState *state, GistSortedBuildLevelState *levelstate, IndexTuple itup)
Definition: gistbuild.c:461
#define GIST_SORTED_BUILD_PAGE_NUM
Definition: gistbuild.c:113
void gistinitpage(Page page, uint32 f)
Definition: gistutil.c:756
int i
Definition: isn.c:73
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
void pfree(void *pointer)
Definition: mcxt.c:1520
void * palloc0(Size size)
Definition: mcxt.c:1346
void * palloc(Size size)
Definition: mcxt.c:1316
@ MAIN_FORKNUM
Definition: relpath.h:50
Page pages[GIST_SORTED_BUILD_PAGE_NUM]
Definition: gistbuild.c:128
struct GistSortedBuildLevelState * parent
Definition: gistbuild.c:127
Definition: regguts.h:323
IndexTuple tuplesort_getindextuple(Tuplesortstate *state, bool forward)

References GistSortedBuildLevelState::current_page, F_LEAF, gist_indexsortbuild_levelstate_add(), gist_indexsortbuild_levelstate_flush(), GIST_ROOT_BLKNO, GIST_SORTED_BUILD_PAGE_NUM, GistBuildLSN, gistinitpage(), i, MAIN_FORKNUM, MemoryContextReset(), GistSortedBuildLevelState::pages, PageSetLSN(), palloc(), palloc0(), GistSortedBuildLevelState::parent, pfree(), smgr_bulk_finish(), smgr_bulk_get_buf(), smgr_bulk_start_rel(), smgr_bulk_write(), and tuplesort_getindextuple().

Referenced by gistbuild().

◆ gist_indexsortbuild_levelstate_add()

static void gist_indexsortbuild_levelstate_add ( GISTBuildState state,
GistSortedBuildLevelState levelstate,
IndexTuple  itup 
)
static

Definition at line 461 of file gistbuild.c.

464 {
465  Size sizeNeeded;
466 
467  /* Check if tuple can be added to the current page */
468  sizeNeeded = IndexTupleSize(itup) + sizeof(ItemIdData); /* fillfactor ignored */
469  if (PageGetFreeSpace(levelstate->pages[levelstate->current_page]) < sizeNeeded)
470  {
471  Page newPage;
472  Page old_page = levelstate->pages[levelstate->current_page];
473  uint16 old_page_flags = GistPageGetOpaque(old_page)->flags;
474 
475  if (levelstate->current_page + 1 == GIST_SORTED_BUILD_PAGE_NUM)
476  {
478  }
479  else
480  levelstate->current_page++;
481 
482  if (levelstate->pages[levelstate->current_page] == NULL)
483  levelstate->pages[levelstate->current_page] = palloc0(BLCKSZ);
484 
485  newPage = levelstate->pages[levelstate->current_page];
486  gistinitpage(newPage, old_page_flags);
487  }
488 
489  gistfillbuffer(levelstate->pages[levelstate->current_page], &itup, 1, InvalidOffsetNumber);
490 }
Size PageGetFreeSpace(Page page)
Definition: bufpage.c:907
Pointer Page
Definition: bufpage.h:78
unsigned short uint16
Definition: c.h:505
#define GistPageGetOpaque(page)
Definition: gist.h:165
void gistfillbuffer(Page page, IndexTuple *itup, int len, OffsetNumber off)
Definition: gistutil.c:33
struct ItemIdData ItemIdData
#define IndexTupleSize(itup)
Definition: itup.h:70
#define InvalidOffsetNumber
Definition: off.h:26

References GistSortedBuildLevelState::current_page, gist_indexsortbuild_levelstate_flush(), GIST_SORTED_BUILD_PAGE_NUM, gistfillbuffer(), gistinitpage(), GistPageGetOpaque, IndexTupleSize, InvalidOffsetNumber, PageGetFreeSpace(), GistSortedBuildLevelState::pages, and palloc0().

Referenced by gist_indexsortbuild(), and gist_indexsortbuild_levelstate_flush().

◆ gist_indexsortbuild_levelstate_flush()

static void gist_indexsortbuild_levelstate_flush ( GISTBuildState state,
GistSortedBuildLevelState levelstate 
)
static

Definition at line 493 of file gistbuild.c.

495 {
497  BlockNumber blkno;
498  MemoryContext oldCtx;
499  IndexTuple union_tuple;
500  SplitPageLayout *dist;
501  IndexTuple *itvec;
502  int vect_len;
503  bool isleaf = GistPageIsLeaf(levelstate->pages[0]);
504 
506 
507  oldCtx = MemoryContextSwitchTo(state->giststate->tempCxt);
508 
509  /* Get index tuples from first page */
510  itvec = gistextractpage(levelstate->pages[0], &vect_len);
511  if (levelstate->current_page > 0)
512  {
513  /* Append tuples from each page */
514  for (int i = 1; i < levelstate->current_page + 1; i++)
515  {
516  int len_local;
517  IndexTuple *itvec_local = gistextractpage(levelstate->pages[i], &len_local);
518 
519  itvec = gistjoinvector(itvec, &vect_len, itvec_local, len_local);
520  pfree(itvec_local);
521  }
522 
523  /* Apply picksplit to list of all collected tuples */
524  dist = gistSplit(state->indexrel, levelstate->pages[0], itvec, vect_len, state->giststate);
525  }
526  else
527  {
528  /* Create split layout from single page */
529  dist = (SplitPageLayout *) palloc0(sizeof(SplitPageLayout));
530  union_tuple = gistunion(state->indexrel, itvec, vect_len,
531  state->giststate);
532  dist->itup = union_tuple;
533  dist->list = gistfillitupvec(itvec, vect_len, &(dist->lenlist));
534  dist->block.num = vect_len;
535  }
536 
537  MemoryContextSwitchTo(oldCtx);
538 
539  /* Reset page counter */
540  levelstate->current_page = 0;
541 
542  /* Create pages for all partitions in split result */
543  for (; dist != NULL; dist = dist->next)
544  {
545  char *data;
547  Page target;
548 
549  /* check once per page */
551 
552  /* Create page and copy data */
553  data = (char *) (dist->list);
554  buf = smgr_bulk_get_buf(state->bulkstate);
555  target = (Page) buf;
556  gistinitpage(target, isleaf ? F_LEAF : 0);
557  for (int i = 0; i < dist->block.num; i++)
558  {
559  IndexTuple thistup = (IndexTuple) data;
560 
561  if (PageAddItem(target, (Item) data, IndexTupleSize(thistup), i + FirstOffsetNumber, false, false) == InvalidOffsetNumber)
562  elog(ERROR, "failed to add item to index page in \"%s\"", RelationGetRelationName(state->indexrel));
563 
564  data += IndexTupleSize(thistup);
565  }
566  union_tuple = dist->itup;
567 
568  /*
569  * Set the right link to point to the previous page. This is just for
570  * debugging purposes: GiST only follows the right link if a page is
571  * split concurrently to a scan, and that cannot happen during index
572  * build.
573  *
574  * It's a bit counterintuitive that we set the right link on the new
575  * page to point to the previous page, not the other way around. But
576  * GiST pages are not ordered like B-tree pages are, so as long as the
577  * right-links form a chain through all the pages at the same level,
578  * the order doesn't matter.
579  */
580  if (levelstate->last_blkno)
581  GistPageGetOpaque(target)->rightlink = levelstate->last_blkno;
582 
583  /*
584  * The page is now complete. Assign a block number to it, and pass it
585  * to the bulk writer.
586  */
587  blkno = state->pages_allocated++;
588  PageSetLSN(target, GistBuildLSN);
589  smgr_bulk_write(state->bulkstate, blkno, buf, true);
590  ItemPointerSetBlockNumber(&(union_tuple->t_tid), blkno);
591  levelstate->last_blkno = blkno;
592 
593  /*
594  * Insert the downlink to the parent page. If this was the root,
595  * create a new page as the parent, which becomes the new root.
596  */
597  parent = levelstate->parent;
598  if (parent == NULL)
599  {
600  parent = palloc0(sizeof(GistSortedBuildLevelState));
601  parent->pages[0] = palloc(BLCKSZ);
602  parent->parent = NULL;
603  gistinitpage(parent->pages[0], 0);
604 
605  levelstate->parent = parent;
606  }
607  gist_indexsortbuild_levelstate_add(state, parent, union_tuple);
608  }
609 }
uint32 BlockNumber
Definition: block.h:31
#define PageAddItem(page, item, size, offsetNumber, overwrite, is_heap)
Definition: bufpage.h:468
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
SplitPageLayout * gistSplit(Relation r, Page page, IndexTuple *itup, int len, GISTSTATE *giststate)
Definition: gist.c:1438
#define GistPageIsLeaf(page)
Definition: gist.h:167
IndexTuple * gistextractpage(Page page, int *len)
Definition: gistutil.c:94
IndexTuple * gistjoinvector(IndexTuple *itvec, int *len, IndexTuple *additvec, int addlen)
Definition: gistutil.c:113
IndexTuple gistunion(Relation r, IndexTuple *itvec, int len, GISTSTATE *giststate)
Definition: gistutil.c:218
IndexTupleData * gistfillitupvec(IndexTuple *vec, int veclen, int *memlen)
Definition: gistutil.c:126
Pointer Item
Definition: item.h:17
static void ItemPointerSetBlockNumber(ItemPointerData *pointer, BlockNumber blockNumber)
Definition: itemptr.h:147
IndexTupleData * IndexTuple
Definition: itup.h:53
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define FirstOffsetNumber
Definition: off.h:27
const void * data
static char * buf
Definition: pg_test_fsync.c:73
MemoryContextSwitchTo(old_ctx)
#define RelationGetRelationName(relation)
Definition: rel.h:539
ItemPointerData t_tid
Definition: itup.h:37
gistxlogPage block
Definition: gist_private.h:193
struct SplitPageLayout * next
Definition: gist_private.h:200
IndexTuple itup
Definition: gist_private.h:196
IndexTupleData * list
Definition: gist_private.h:194

References SplitPageLayout::block, buf, CHECK_FOR_INTERRUPTS, GistSortedBuildLevelState::current_page, data, elog, ERROR, F_LEAF, FirstOffsetNumber, gist_indexsortbuild_levelstate_add(), GistBuildLSN, gistextractpage(), gistfillitupvec(), gistinitpage(), gistjoinvector(), GistPageGetOpaque, GistPageIsLeaf, gistSplit(), gistunion(), i, IndexTupleSize, InvalidOffsetNumber, ItemPointerSetBlockNumber(), SplitPageLayout::itup, GistSortedBuildLevelState::last_blkno, SplitPageLayout::lenlist, SplitPageLayout::list, MemoryContextSwitchTo(), SplitPageLayout::next, gistxlogPage::num, PageAddItem, GistSortedBuildLevelState::pages, PageSetLSN(), palloc(), palloc0(), GistSortedBuildLevelState::parent, pfree(), RelationGetRelationName, smgr_bulk_get_buf(), smgr_bulk_write(), and IndexTupleData::t_tid.

Referenced by gist_indexsortbuild(), and gist_indexsortbuild_levelstate_add().

◆ gistBufferingBuildInsert()

static void gistBufferingBuildInsert ( GISTBuildState buildstate,
IndexTuple  itup 
)
static

Definition at line 907 of file gistbuild.c.

908 {
909  /* Insert the tuple to buffers. */
910  gistProcessItup(buildstate, itup, 0, buildstate->gfbb->rootlevel);
911 
912  /* If we filled up (half of a) buffer, process buffer emptying. */
913  gistProcessEmptyingQueue(buildstate);
914 }
static bool gistProcessItup(GISTBuildState *buildstate, IndexTuple itup, BlockNumber startblkno, int startlevel)
Definition: gistbuild.c:923
static void gistProcessEmptyingQueue(GISTBuildState *buildstate)
Definition: gistbuild.c:1297
GISTBuildBuffers * gfbb
Definition: gistbuild.c:100

References GISTBuildState::gfbb, gistProcessEmptyingQueue(), gistProcessItup(), and GISTBuildBuffers::rootlevel.

Referenced by gistBuildCallback().

◆ gistBufferingFindCorrectParent()

static Buffer gistBufferingFindCorrectParent ( GISTBuildState buildstate,
BlockNumber  childblkno,
int  level,
BlockNumber parentblkno,
OffsetNumber downlinkoffnum 
)
static

Definition at line 1223 of file gistbuild.c.

1227 {
1228  BlockNumber parent;
1229  Buffer buffer;
1230  Page page;
1231  OffsetNumber maxoff;
1232  OffsetNumber off;
1233 
1234  if (level > 0)
1235  parent = gistGetParent(buildstate, childblkno);
1236  else
1237  {
1238  /*
1239  * For a leaf page, the caller must supply a correct parent block
1240  * number.
1241  */
1242  if (*parentblkno == InvalidBlockNumber)
1243  elog(ERROR, "no parent buffer provided of child %u", childblkno);
1244  parent = *parentblkno;
1245  }
1246 
1247  buffer = ReadBuffer(buildstate->indexrel, parent);
1248  page = BufferGetPage(buffer);
1249  LockBuffer(buffer, GIST_EXCLUSIVE);
1250  gistcheckpage(buildstate->indexrel, buffer);
1251  maxoff = PageGetMaxOffsetNumber(page);
1252 
1253  /* Check if it was not moved */
1254  if (parent == *parentblkno && *parentblkno != InvalidBlockNumber &&
1255  *downlinkoffnum != InvalidOffsetNumber && *downlinkoffnum <= maxoff)
1256  {
1257  ItemId iid = PageGetItemId(page, *downlinkoffnum);
1258  IndexTuple idxtuple = (IndexTuple) PageGetItem(page, iid);
1259 
1260  if (ItemPointerGetBlockNumber(&(idxtuple->t_tid)) == childblkno)
1261  {
1262  /* Still there */
1263  return buffer;
1264  }
1265  }
1266 
1267  /*
1268  * Downlink was not at the offset where it used to be. Scan the page to
1269  * find it. During normal gist insertions, it might've moved to another
1270  * page, to the right, but during a buffering build, we keep track of the
1271  * parent of each page in the lookup table so we should always know what
1272  * page it's on.
1273  */
1274  for (off = FirstOffsetNumber; off <= maxoff; off = OffsetNumberNext(off))
1275  {
1276  ItemId iid = PageGetItemId(page, off);
1277  IndexTuple idxtuple = (IndexTuple) PageGetItem(page, iid);
1278 
1279  if (ItemPointerGetBlockNumber(&(idxtuple->t_tid)) == childblkno)
1280  {
1281  /* yes!!, found it */
1282  *downlinkoffnum = off;
1283  return buffer;
1284  }
1285  }
1286 
1287  elog(ERROR, "failed to re-find parent for block %u", childblkno);
1288  return InvalidBuffer; /* keep compiler quiet */
1289 }
#define InvalidBlockNumber
Definition: block.h:33
int Buffer
Definition: buf.h:23
#define InvalidBuffer
Definition: buf.h:25
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5131
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:745
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:404
static Item PageGetItem(Page page, ItemId itemId)
Definition: bufpage.h:351
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:240
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:369
#define GIST_EXCLUSIVE
Definition: gist_private.h:43
static BlockNumber gistGetParent(GISTBuildState *buildstate, BlockNumber child)
Definition: gistbuild.c:1565
void gistcheckpage(Relation rel, Buffer buf)
Definition: gistutil.c:784
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
uint16 OffsetNumber
Definition: off.h:24
Relation indexrel
Definition: gistbuild.c:84

References BufferGetPage(), elog, ERROR, FirstOffsetNumber, GIST_EXCLUSIVE, gistcheckpage(), gistGetParent(), GISTBuildState::indexrel, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, ItemPointerGetBlockNumber(), LockBuffer(), OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), GistSortedBuildLevelState::parent, ReadBuffer(), and IndexTupleData::t_tid.

Referenced by gistbufferinginserttuples().

◆ gistbufferinginserttuples()

static BlockNumber gistbufferinginserttuples ( GISTBuildState buildstate,
Buffer  buffer,
int  level,
IndexTuple itup,
int  ntup,
OffsetNumber  oldoffnum,
BlockNumber  parentblk,
OffsetNumber  downlinkoffnum 
)
static

Definition at line 1054 of file gistbuild.c.

1057 {
1058  GISTBuildBuffers *gfbb = buildstate->gfbb;
1059  List *splitinfo;
1060  bool is_split;
1061  BlockNumber placed_to_blk = InvalidBlockNumber;
1062 
1063  is_split = gistplacetopage(buildstate->indexrel,
1064  buildstate->freespace,
1065  buildstate->giststate,
1066  buffer,
1067  itup, ntup, oldoffnum, &placed_to_blk,
1068  InvalidBuffer,
1069  &splitinfo,
1070  false,
1071  buildstate->heaprel, true);
1072 
1073  /*
1074  * If this is a root split, update the root path item kept in memory. This
1075  * ensures that all path stacks are always complete, including all parent
1076  * nodes up to the root. That simplifies the algorithm to re-find correct
1077  * parent.
1078  */
1079  if (is_split && BufferGetBlockNumber(buffer) == GIST_ROOT_BLKNO)
1080  {
1081  Page page = BufferGetPage(buffer);
1082  OffsetNumber off;
1083  OffsetNumber maxoff;
1084 
1085  Assert(level == gfbb->rootlevel);
1086  gfbb->rootlevel++;
1087 
1088  elog(DEBUG2, "splitting GiST root page, now %d levels deep", gfbb->rootlevel);
1089 
1090  /*
1091  * All the downlinks on the old root page are now on one of the child
1092  * pages. Visit all the new child pages to memorize the parents of the
1093  * grandchildren.
1094  */
1095  if (gfbb->rootlevel > 1)
1096  {
1097  maxoff = PageGetMaxOffsetNumber(page);
1098  for (off = FirstOffsetNumber; off <= maxoff; off++)
1099  {
1100  ItemId iid = PageGetItemId(page, off);
1101  IndexTuple idxtuple = (IndexTuple) PageGetItem(page, iid);
1102  BlockNumber childblkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
1103  Buffer childbuf = ReadBuffer(buildstate->indexrel, childblkno);
1104 
1105  LockBuffer(childbuf, GIST_SHARE);
1106  gistMemorizeAllDownlinks(buildstate, childbuf);
1107  UnlockReleaseBuffer(childbuf);
1108 
1109  /*
1110  * Also remember that the parent of the new child page is the
1111  * root block.
1112  */
1113  gistMemorizeParent(buildstate, childblkno, GIST_ROOT_BLKNO);
1114  }
1115  }
1116  }
1117 
1118  if (splitinfo)
1119  {
1120  /*
1121  * Insert the downlinks to the parent. This is analogous with
1122  * gistfinishsplit() in the regular insertion code, but the locking is
1123  * simpler, and we have to maintain the buffers on internal nodes and
1124  * the parent map.
1125  */
1126  IndexTuple *downlinks;
1127  int ndownlinks,
1128  i;
1129  Buffer parentBuffer;
1130  ListCell *lc;
1131 
1132  /* Parent may have changed since we memorized this path. */
1133  parentBuffer =
1134  gistBufferingFindCorrectParent(buildstate,
1135  BufferGetBlockNumber(buffer),
1136  level,
1137  &parentblk,
1138  &downlinkoffnum);
1139 
1140  /*
1141  * If there's a buffer associated with this page, that needs to be
1142  * split too. gistRelocateBuildBuffersOnSplit() will also adjust the
1143  * downlinks in 'splitinfo', to make sure they're consistent not only
1144  * with the tuples already on the pages, but also the tuples in the
1145  * buffers that will eventually be inserted to them.
1146  */
1148  buildstate->giststate,
1149  buildstate->indexrel,
1150  level,
1151  buffer, splitinfo);
1152 
1153  /* Create an array of all the downlink tuples */
1154  ndownlinks = list_length(splitinfo);
1155  downlinks = (IndexTuple *) palloc(sizeof(IndexTuple) * ndownlinks);
1156  i = 0;
1157  foreach(lc, splitinfo)
1158  {
1159  GISTPageSplitInfo *splitinfo = lfirst(lc);
1160 
1161  /*
1162  * Remember the parent of each new child page in our parent map.
1163  * This assumes that the downlinks fit on the parent page. If the
1164  * parent page is split, too, when we recurse up to insert the
1165  * downlinks, the recursive gistbufferinginserttuples() call will
1166  * update the map again.
1167  */
1168  if (level > 0)
1169  gistMemorizeParent(buildstate,
1170  BufferGetBlockNumber(splitinfo->buf),
1171  BufferGetBlockNumber(parentBuffer));
1172 
1173  /*
1174  * Also update the parent map for all the downlinks that got moved
1175  * to a different page. (actually this also loops through the
1176  * downlinks that stayed on the original page, but it does no
1177  * harm).
1178  */
1179  if (level > 1)
1180  gistMemorizeAllDownlinks(buildstate, splitinfo->buf);
1181 
1182  /*
1183  * Since there's no concurrent access, we can release the lower
1184  * level buffers immediately. This includes the original page.
1185  */
1186  UnlockReleaseBuffer(splitinfo->buf);
1187  downlinks[i++] = splitinfo->downlink;
1188  }
1189 
1190  /* Insert them into parent. */
1191  gistbufferinginserttuples(buildstate, parentBuffer, level + 1,
1192  downlinks, ndownlinks, downlinkoffnum,
1194 
1195  list_free_deep(splitinfo); /* we don't need this anymore */
1196  }
1197  else
1198  UnlockReleaseBuffer(buffer);
1199 
1200  return placed_to_blk;
1201 }
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:3713
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4913
#define Assert(condition)
Definition: c.h:858
#define DEBUG2
Definition: elog.h:29
bool gistplacetopage(Relation rel, Size freespace, GISTSTATE *giststate, Buffer buffer, IndexTuple *itup, int ntup, OffsetNumber oldoffnum, BlockNumber *newblkno, Buffer leftchildbuf, List **splitinfo, bool markfollowright, Relation heapRel, bool is_build)
Definition: gist.c:225
#define GIST_SHARE
Definition: gist_private.h:42
static BlockNumber gistbufferinginserttuples(GISTBuildState *buildstate, Buffer buffer, int level, IndexTuple *itup, int ntup, OffsetNumber oldoffnum, BlockNumber parentblk, OffsetNumber downlinkoffnum)
Definition: gistbuild.c:1054
static void gistMemorizeAllDownlinks(GISTBuildState *buildstate, Buffer parentbuf)
Definition: gistbuild.c:1544
static Buffer gistBufferingFindCorrectParent(GISTBuildState *buildstate, BlockNumber childblkno, int level, BlockNumber *parentblkno, OffsetNumber *downlinkoffnum)
Definition: gistbuild.c:1223
static void gistMemorizeParent(GISTBuildState *buildstate, BlockNumber child, BlockNumber parent)
Definition: gistbuild.c:1528
void gistRelocateBuildBuffersOnSplit(GISTBuildBuffers *gfbb, GISTSTATE *giststate, Relation r, int level, Buffer buffer, List *splitinfo)
void list_free_deep(List *list)
Definition: list.c:1560
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
GISTSTATE * giststate
Definition: gistbuild.c:86
Relation heaprel
Definition: gistbuild.c:85
IndexTuple downlink
Definition: gist_private.h:422
Definition: pg_list.h:54

References Assert, GISTPageSplitInfo::buf, BufferGetBlockNumber(), BufferGetPage(), DEBUG2, GISTPageSplitInfo::downlink, elog, FirstOffsetNumber, GISTBuildState::freespace, GISTBuildState::gfbb, GIST_ROOT_BLKNO, GIST_SHARE, gistBufferingFindCorrectParent(), gistMemorizeAllDownlinks(), gistMemorizeParent(), gistplacetopage(), gistRelocateBuildBuffersOnSplit(), GISTBuildState::giststate, GISTBuildState::heaprel, i, GISTBuildState::indexrel, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, ItemPointerGetBlockNumber(), lfirst, list_free_deep(), list_length(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), palloc(), ReadBuffer(), GISTBuildBuffers::rootlevel, IndexTupleData::t_tid, and UnlockReleaseBuffer().

Referenced by gistProcessItup().

◆ gistbuild()

IndexBuildResult* gistbuild ( Relation  heap,
Relation  index,
IndexInfo indexInfo 
)

Definition at line 179 of file gistbuild.c.

180 {
181  IndexBuildResult *result;
182  double reltuples;
183  GISTBuildState buildstate;
185  int fillfactor;
186  Oid SortSupportFnOids[INDEX_MAX_KEYS];
187  GiSTOptions *options = (GiSTOptions *) index->rd_options;
188 
189  /*
190  * We expect to be called exactly once for any index relation. If that's
191  * not the case, big trouble's what we have.
192  */
194  elog(ERROR, "index \"%s\" already contains data",
196 
197  buildstate.indexrel = index;
198  buildstate.heaprel = heap;
199  buildstate.sortstate = NULL;
200  buildstate.giststate = initGISTstate(index);
201 
202  /*
203  * Create a temporary memory context that is reset once for each tuple
204  * processed. (Note: we don't bother to make this a child of the
205  * giststate's scanCxt, so we have to delete it separately at the end.)
206  */
207  buildstate.giststate->tempCxt = createTempGistContext();
208 
209  /*
210  * Choose build strategy. First check whether the user specified to use
211  * buffering mode. (The use-case for that in the field is somewhat
212  * questionable perhaps, but it's important for testing purposes.)
213  */
214  if (options)
215  {
216  if (options->buffering_mode == GIST_OPTION_BUFFERING_ON)
217  buildstate.buildMode = GIST_BUFFERING_STATS;
218  else if (options->buffering_mode == GIST_OPTION_BUFFERING_OFF)
219  buildstate.buildMode = GIST_BUFFERING_DISABLED;
220  else /* must be "auto" */
221  buildstate.buildMode = GIST_BUFFERING_AUTO;
222  }
223  else
224  {
225  buildstate.buildMode = GIST_BUFFERING_AUTO;
226  }
227 
228  /*
229  * Unless buffering mode was forced, see if we can use sorting instead.
230  */
231  if (buildstate.buildMode != GIST_BUFFERING_STATS)
232  {
233  bool hasallsortsupports = true;
235 
236  for (int i = 0; i < keyscount; i++)
237  {
238  SortSupportFnOids[i] = index_getprocid(index, i + 1,
240  if (!OidIsValid(SortSupportFnOids[i]))
241  {
242  hasallsortsupports = false;
243  break;
244  }
245  }
246  if (hasallsortsupports)
247  buildstate.buildMode = GIST_SORTED_BUILD;
248  }
249 
250  /*
251  * Calculate target amount of free space to leave on pages.
252  */
254  buildstate.freespace = BLCKSZ * (100 - fillfactor) / 100;
255 
256  /*
257  * Build the index using the chosen strategy.
258  */
259  buildstate.indtuples = 0;
260  buildstate.indtuplesSize = 0;
261 
262  if (buildstate.buildMode == GIST_SORTED_BUILD)
263  {
264  /*
265  * Sort all data, build the index from bottom up.
266  */
267  buildstate.sortstate = tuplesort_begin_index_gist(heap,
268  index,
270  NULL,
272 
273  /* Scan the table, adding all tuples to the tuplesort */
274  reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
276  (void *) &buildstate, NULL);
277 
278  /*
279  * Perform the sort and build index pages.
280  */
281  tuplesort_performsort(buildstate.sortstate);
282 
283  gist_indexsortbuild(&buildstate);
284 
285  tuplesort_end(buildstate.sortstate);
286  }
287  else
288  {
289  /*
290  * Initialize an empty index and insert all tuples, possibly using
291  * buffers on intermediate levels.
292  */
293  Buffer buffer;
294  Page page;
295 
296  /* initialize the root page */
297  buffer = gistNewBuffer(index, heap);
299  page = BufferGetPage(buffer);
300 
302 
303  GISTInitBuffer(buffer, F_LEAF);
304 
305  MarkBufferDirty(buffer);
306  PageSetLSN(page, GistBuildLSN);
307 
308  UnlockReleaseBuffer(buffer);
309 
311 
312  /* Scan the table, inserting all the tuples to the index. */
313  reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
315  (void *) &buildstate, NULL);
316 
317  /*
318  * If buffering was used, flush out all the tuples that are still in
319  * the buffers.
320  */
321  if (buildstate.buildMode == GIST_BUFFERING_ACTIVE)
322  {
323  elog(DEBUG1, "all tuples processed, emptying buffers");
324  gistEmptyAllBuffers(&buildstate);
325  gistFreeBuildBuffers(buildstate.gfbb);
326  }
327 
328  /*
329  * We didn't write WAL records as we built the index, so if
330  * WAL-logging is required, write all pages to the WAL now.
331  */
332  if (RelationNeedsWAL(index))
333  {
336  true);
337  }
338  }
339 
340  /* okay, all heap tuples are indexed */
341  MemoryContextSwitchTo(oldcxt);
343 
344  freeGISTstate(buildstate.giststate);
345 
346  /*
347  * Return statistics
348  */
349  result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
350 
351  result->heap_tuples = reltuples;
352  result->index_tuples = (double) buildstate.indtuples;
353 
354  return result;
355 }
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2520
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:277
#define OidIsValid(objectId)
Definition: c.h:775
#define DEBUG1
Definition: elog.h:30
GISTSTATE * initGISTstate(Relation index)
Definition: gist.c:1525
MemoryContext createTempGistContext(void)
Definition: gist.c:122
void freeGISTstate(GISTSTATE *giststate)
Definition: gist.c:1653
#define GIST_SORTSUPPORT_PROC
Definition: gist.h:40
@ GIST_OPTION_BUFFERING_OFF
Definition: gist_private.h:388
@ GIST_OPTION_BUFFERING_ON
Definition: gist_private.h:387
#define GIST_DEFAULT_FILLFACTOR
Definition: gist_private.h:480
static void gist_indexsortbuild(GISTBuildState *state)
Definition: gistbuild.c:400
static void gistBuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
Definition: gistbuild.c:820
static void gistSortedBuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
Definition: gistbuild.c:366
static void gistEmptyAllBuffers(GISTBuildState *buildstate)
Definition: gistbuild.c:1370
void gistFreeBuildBuffers(GISTBuildBuffers *gfbb)
Buffer gistNewBuffer(Relation r, Relation heaprel)
Definition: gistutil.c:823
void GISTInitBuffer(Buffer b, uint32 f)
Definition: gistutil.c:772
int maintenance_work_mem
Definition: globals.c:130
RegProcedure index_getprocid(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:826
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
#define INDEX_MAX_KEYS
int fillfactor
Definition: pgbench.c:187
unsigned int Oid
Definition: postgres_ext.h:31
#define RelationNeedsWAL(relation)
Definition: rel.h:628
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition: rel.h:524
Tuplesortstate * sortstate
Definition: gistbuild.c:106
GistBuildMode buildMode
Definition: gistbuild.c:90
MemoryContext tempCxt
Definition: gist_private.h:78
double heap_tuples
Definition: genam.h:32
double index_tuples
Definition: genam.h:33
Definition: type.h:95
static double table_index_build_scan(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
Definition: tableam.h:1785
void tuplesort_performsort(Tuplesortstate *state)
Definition: tuplesort.c:1385
void tuplesort_end(Tuplesortstate *state)
Definition: tuplesort.c:971
#define TUPLESORT_NONE
Definition: tuplesort.h:93
Tuplesortstate * tuplesort_begin_index_gist(Relation heapRel, Relation indexRel, int workMem, SortCoordinate coordinate, int sortopt)
void log_newpage_range(Relation rel, ForkNumber forknum, BlockNumber startblk, BlockNumber endblk, bool page_std)
Definition: xloginsert.c:1270

References Assert, BufferGetBlockNumber(), BufferGetPage(), GISTBuildState::buildMode, createTempGistContext(), CurrentMemoryContext, DEBUG1, elog, END_CRIT_SECTION, ERROR, F_LEAF, fillfactor, freeGISTstate(), GISTBuildState::freespace, GIST_BUFFERING_ACTIVE, GIST_BUFFERING_AUTO, GIST_BUFFERING_DISABLED, GIST_BUFFERING_STATS, GIST_DEFAULT_FILLFACTOR, gist_indexsortbuild(), GIST_OPTION_BUFFERING_OFF, GIST_OPTION_BUFFERING_ON, GIST_ROOT_BLKNO, GIST_SORTED_BUILD, GIST_SORTSUPPORT_PROC, gistBuildCallback(), GistBuildLSN, gistEmptyAllBuffers(), gistFreeBuildBuffers(), GISTInitBuffer(), gistNewBuffer(), gistSortedBuildCallback(), GISTBuildState::giststate, IndexBuildResult::heap_tuples, GISTBuildState::heaprel, i, if(), index_getprocid(), INDEX_MAX_KEYS, IndexBuildResult::index_tuples, GISTBuildState::indexrel, IndexRelationGetNumberOfKeyAttributes, GISTBuildState::indtuples, GISTBuildState::indtuplesSize, initGISTstate(), log_newpage_range(), MAIN_FORKNUM, maintenance_work_mem, MarkBufferDirty(), MemoryContextDelete(), MemoryContextSwitchTo(), OidIsValid, PageSetLSN(), palloc(), RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, GISTBuildState::sortstate, START_CRIT_SECTION, table_index_build_scan(), GISTSTATE::tempCxt, tuplesort_begin_index_gist(), tuplesort_end(), TUPLESORT_NONE, tuplesort_performsort(), and UnlockReleaseBuffer().

Referenced by gisthandler().

◆ gistBuildCallback()

static void gistBuildCallback ( Relation  index,
ItemPointer  tid,
Datum values,
bool isnull,
bool  tupleIsAlive,
void *  state 
)
static

Definition at line 820 of file gistbuild.c.

826 {
827  GISTBuildState *buildstate = (GISTBuildState *) state;
828  IndexTuple itup;
829  MemoryContext oldCtx;
830 
831  oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
832 
833  /* form an index tuple and point it at the heap tuple */
834  itup = gistFormTuple(buildstate->giststate, index,
835  values, isnull,
836  true);
837  itup->t_tid = *tid;
838 
839  /* Update tuple count and total size. */
840  buildstate->indtuples += 1;
841  buildstate->indtuplesSize += IndexTupleSize(itup);
842 
843  /*
844  * XXX In buffering builds, the tempCxt is also reset down inside
845  * gistProcessEmptyingQueue(). This is not great because it risks
846  * confusion and possible use of dangling pointers (for example, itup
847  * might be already freed when control returns here). It's generally
848  * better that a memory context be "owned" by only one function. However,
849  * currently this isn't causing issues so it doesn't seem worth the amount
850  * of refactoring that would be needed to avoid it.
851  */
852  if (buildstate->buildMode == GIST_BUFFERING_ACTIVE)
853  {
854  /* We have buffers, so use them. */
855  gistBufferingBuildInsert(buildstate, itup);
856  }
857  else
858  {
859  /*
860  * There's no buffers (yet). Since we already have the index relation
861  * locked, we call gistdoinsert directly.
862  */
863  gistdoinsert(index, itup, buildstate->freespace,
864  buildstate->giststate, buildstate->heaprel, true);
865  }
866 
867  MemoryContextSwitchTo(oldCtx);
868  MemoryContextReset(buildstate->giststate->tempCxt);
869 
870  if (buildstate->buildMode == GIST_BUFFERING_ACTIVE &&
872  {
873  /* Adjust the target buffer size now */
874  buildstate->gfbb->pagesPerBuffer =
875  calculatePagesPerBuffer(buildstate, buildstate->gfbb->levelStep);
876  }
877 
878  /*
879  * In 'auto' mode, check if the index has grown too large to fit in cache,
880  * and switch to buffering mode if it has.
881  *
882  * To avoid excessive calls to smgrnblocks(), only check this every
883  * BUFFERING_MODE_SWITCH_CHECK_STEP index tuples.
884  *
885  * In 'stats' state, switch as soon as we have seen enough tuples to have
886  * some idea of the average tuple size.
887  */
888  if ((buildstate->buildMode == GIST_BUFFERING_AUTO &&
889  buildstate->indtuples % BUFFERING_MODE_SWITCH_CHECK_STEP == 0 &&
891  MAIN_FORKNUM)) ||
892  (buildstate->buildMode == GIST_BUFFERING_STATS &&
894  {
895  /*
896  * Index doesn't fit in effective cache anymore. Try to switch to
897  * buffering build mode.
898  */
899  gistInitBuffering(buildstate);
900  }
901 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
int effective_cache_size
Definition: costsize.c:128
void gistdoinsert(Relation r, IndexTuple itup, Size freespace, GISTSTATE *giststate, Relation heapRel, bool is_build)
Definition: gist.c:634
#define BUFFERING_MODE_SWITCH_CHECK_STEP
Definition: gistbuild.c:52
static int calculatePagesPerBuffer(GISTBuildState *buildstate, int levelStep)
Definition: gistbuild.c:787
#define BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET
Definition: gistbuild.c:60
static void gistInitBuffering(GISTBuildState *buildstate)
Definition: gistbuild.c:626
static void gistBufferingBuildInsert(GISTBuildState *buildstate, IndexTuple itup)
Definition: gistbuild.c:907
IndexTuple gistFormTuple(GISTSTATE *giststate, Relation r, const Datum *attdata, const bool *isnull, bool isleaf)
Definition: gistutil.c:574
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:567
BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:655

References BUFFERING_MODE_SWITCH_CHECK_STEP, BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET, GISTBuildState::buildMode, calculatePagesPerBuffer(), effective_cache_size, GISTBuildState::freespace, GISTBuildState::gfbb, GIST_BUFFERING_ACTIVE, GIST_BUFFERING_AUTO, GIST_BUFFERING_STATS, gistBufferingBuildInsert(), gistdoinsert(), gistFormTuple(), gistInitBuffering(), GISTBuildState::giststate, GISTBuildState::heaprel, IndexTupleSize, GISTBuildState::indtuples, GISTBuildState::indtuplesSize, GISTBuildBuffers::levelStep, MAIN_FORKNUM, MemoryContextReset(), MemoryContextSwitchTo(), GISTBuildBuffers::pagesPerBuffer, RelationGetSmgr(), smgrnblocks(), IndexTupleData::t_tid, GISTSTATE::tempCxt, and values.

Referenced by gistbuild().

◆ gistEmptyAllBuffers()

static void gistEmptyAllBuffers ( GISTBuildState buildstate)
static

Definition at line 1370 of file gistbuild.c.

1371 {
1372  GISTBuildBuffers *gfbb = buildstate->gfbb;
1373  MemoryContext oldCtx;
1374  int i;
1375 
1376  oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
1377 
1378  /*
1379  * Iterate through the levels from top to bottom.
1380  */
1381  for (i = gfbb->buffersOnLevelsLen - 1; i >= 0; i--)
1382  {
1383  /*
1384  * Empty all buffers on this level. Note that new buffers can pop up
1385  * in the list during the processing, as a result of page splits, so a
1386  * simple walk through the list won't work. We remove buffers from the
1387  * list when we see them empty; a buffer can't become non-empty once
1388  * it's been fully emptied.
1389  */
1390  while (gfbb->buffersOnLevels[i] != NIL)
1391  {
1392  GISTNodeBuffer *nodeBuffer;
1393 
1394  nodeBuffer = (GISTNodeBuffer *) linitial(gfbb->buffersOnLevels[i]);
1395 
1396  if (nodeBuffer->blocksCount != 0)
1397  {
1398  /*
1399  * Add this buffer to the emptying queue, and proceed to empty
1400  * the queue.
1401  */
1402  if (!nodeBuffer->queuedForEmptying)
1403  {
1405  nodeBuffer->queuedForEmptying = true;
1406  gfbb->bufferEmptyingQueue =
1407  lcons(nodeBuffer, gfbb->bufferEmptyingQueue);
1408  MemoryContextSwitchTo(buildstate->giststate->tempCxt);
1409  }
1410  gistProcessEmptyingQueue(buildstate);
1411  }
1412  else
1413  gfbb->buffersOnLevels[i] =
1415  }
1416  elog(DEBUG2, "emptied all buffers at level %d", i);
1417  }
1418  MemoryContextSwitchTo(oldCtx);
1419 }
List * list_delete_first(List *list)
Definition: list.c:943
List * lcons(void *datum, List *list)
Definition: list.c:495
#define NIL
Definition: pg_list.h:68
#define linitial(l)
Definition: pg_list.h:178
List * bufferEmptyingQueue
Definition: gist_private.h:357
List ** buffersOnLevels
Definition: gist_private.h:368
MemoryContext context
Definition: gist_private.h:341
bool queuedForEmptying
Definition: gist_private.h:307

References GISTNodeBuffer::blocksCount, GISTBuildBuffers::bufferEmptyingQueue, GISTBuildBuffers::buffersOnLevels, GISTBuildBuffers::buffersOnLevelsLen, GISTBuildBuffers::context, DEBUG2, elog, GISTBuildState::gfbb, gistProcessEmptyingQueue(), GISTBuildState::giststate, i, lcons(), linitial, list_delete_first(), MemoryContextSwitchTo(), NIL, GISTNodeBuffer::queuedForEmptying, and GISTSTATE::tempCxt.

Referenced by gistbuild().

◆ gistGetMaxLevel()

static int gistGetMaxLevel ( Relation  index)
static

Definition at line 1425 of file gistbuild.c.

1426 {
1427  int maxLevel;
1428  BlockNumber blkno;
1429 
1430  /*
1431  * Traverse down the tree, starting from the root, until we hit the leaf
1432  * level.
1433  */
1434  maxLevel = 0;
1435  blkno = GIST_ROOT_BLKNO;
1436  while (true)
1437  {
1438  Buffer buffer;
1439  Page page;
1440  IndexTuple itup;
1441 
1442  buffer = ReadBuffer(index, blkno);
1443 
1444  /*
1445  * There's no concurrent access during index build, so locking is just
1446  * pro forma.
1447  */
1448  LockBuffer(buffer, GIST_SHARE);
1449  page = (Page) BufferGetPage(buffer);
1450 
1451  if (GistPageIsLeaf(page))
1452  {
1453  /* We hit the bottom, so we're done. */
1454  UnlockReleaseBuffer(buffer);
1455  break;
1456  }
1457 
1458  /*
1459  * Pick the first downlink on the page, and follow it. It doesn't
1460  * matter which downlink we choose, the tree has the same depth
1461  * everywhere, so we just pick the first one.
1462  */
1463  itup = (IndexTuple) PageGetItem(page,
1465  blkno = ItemPointerGetBlockNumber(&(itup->t_tid));
1466  UnlockReleaseBuffer(buffer);
1467 
1468  /*
1469  * We're going down on the tree. It means that there is yet one more
1470  * level in the tree.
1471  */
1472  maxLevel++;
1473  }
1474  return maxLevel;
1475 }

References BufferGetPage(), FirstOffsetNumber, GIST_ROOT_BLKNO, GIST_SHARE, GistPageIsLeaf, ItemPointerGetBlockNumber(), LockBuffer(), PageGetItem(), PageGetItemId(), ReadBuffer(), IndexTupleData::t_tid, and UnlockReleaseBuffer().

Referenced by gistInitBuffering().

◆ gistGetParent()

static BlockNumber gistGetParent ( GISTBuildState buildstate,
BlockNumber  child 
)
static

Definition at line 1565 of file gistbuild.c.

1566 {
1567  ParentMapEntry *entry;
1568  bool found;
1569 
1570  /* Find node buffer in hash table */
1571  entry = (ParentMapEntry *) hash_search(buildstate->parentMap,
1572  &child,
1573  HASH_FIND,
1574  &found);
1575  if (!found)
1576  elog(ERROR, "could not find parent of block %u in lookup table", child);
1577 
1578  return entry->parentblkno;
1579 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
@ HASH_FIND
Definition: hsearch.h:113
HTAB * parentMap
Definition: gistbuild.c:101
BlockNumber parentblkno
Definition: gistbuild.c:1510

References elog, ERROR, HASH_FIND, hash_search(), ParentMapEntry::parentblkno, and GISTBuildState::parentMap.

Referenced by gistBufferingFindCorrectParent().

◆ gistInitBuffering()

static void gistInitBuffering ( GISTBuildState buildstate)
static

Definition at line 626 of file gistbuild.c.

627 {
628  Relation index = buildstate->indexrel;
629  int pagesPerBuffer;
630  Size pageFreeSpace;
631  Size itupAvgSize,
632  itupMinSize;
633  double avgIndexTuplesPerPage,
634  maxIndexTuplesPerPage;
635  int i;
636  int levelStep;
637 
638  /* Calc space of index page which is available for index tuples */
639  pageFreeSpace = BLCKSZ - SizeOfPageHeaderData - sizeof(GISTPageOpaqueData)
640  - sizeof(ItemIdData)
641  - buildstate->freespace;
642 
643  /*
644  * Calculate average size of already inserted index tuples using gathered
645  * statistics.
646  */
647  itupAvgSize = (double) buildstate->indtuplesSize /
648  (double) buildstate->indtuples;
649 
650  /*
651  * Calculate minimal possible size of index tuple by index metadata.
652  * Minimal possible size of varlena is VARHDRSZ.
653  *
654  * XXX: that's not actually true, as a short varlen can be just 2 bytes.
655  * And we should take padding into account here.
656  */
657  itupMinSize = (Size) MAXALIGN(sizeof(IndexTupleData));
658  for (i = 0; i < index->rd_att->natts; i++)
659  {
660  if (TupleDescAttr(index->rd_att, i)->attlen < 0)
661  itupMinSize += VARHDRSZ;
662  else
663  itupMinSize += TupleDescAttr(index->rd_att, i)->attlen;
664  }
665 
666  /* Calculate average and maximal number of index tuples which fit to page */
667  avgIndexTuplesPerPage = pageFreeSpace / itupAvgSize;
668  maxIndexTuplesPerPage = pageFreeSpace / itupMinSize;
669 
670  /*
671  * We need to calculate two parameters for the buffering algorithm:
672  * levelStep and pagesPerBuffer.
673  *
674  * levelStep determines the size of subtree that we operate on, while
675  * emptying a buffer. A higher value is better, as you need fewer buffer
676  * emptying steps to build the index. However, if you set it too high, the
677  * subtree doesn't fit in cache anymore, and you quickly lose the benefit
678  * of the buffers.
679  *
680  * In Arge et al's paper, levelStep is chosen as logB(M/4B), where B is
681  * the number of tuples on page (ie. fanout), and M is the amount of
682  * internal memory available. Curiously, they doesn't explain *why* that
683  * setting is optimal. We calculate it by taking the highest levelStep so
684  * that a subtree still fits in cache. For a small B, our way of
685  * calculating levelStep is very close to Arge et al's formula. For a
686  * large B, our formula gives a value that is 2x higher.
687  *
688  * The average size (in pages) of a subtree of depth n can be calculated
689  * as a geometric series:
690  *
691  * B^0 + B^1 + B^2 + ... + B^n = (1 - B^(n + 1)) / (1 - B)
692  *
693  * where B is the average number of index tuples on page. The subtree is
694  * cached in the shared buffer cache and the OS cache, so we choose
695  * levelStep so that the subtree size is comfortably smaller than
696  * effective_cache_size, with a safety factor of 4.
697  *
698  * The estimate on the average number of index tuples on page is based on
699  * average tuple sizes observed before switching to buffered build, so the
700  * real subtree size can be somewhat larger. Also, it would selfish to
701  * gobble the whole cache for our index build. The safety factor of 4
702  * should account for those effects.
703  *
704  * The other limiting factor for setting levelStep is that while
705  * processing a subtree, we need to hold one page for each buffer at the
706  * next lower buffered level. The max. number of buffers needed for that
707  * is maxIndexTuplesPerPage^levelStep. This is very conservative, but
708  * hopefully maintenance_work_mem is set high enough that you're
709  * constrained by effective_cache_size rather than maintenance_work_mem.
710  *
711  * XXX: the buffer hash table consumes a fair amount of memory too per
712  * buffer, but that is not currently taken into account. That scales on
713  * the total number of buffers used, ie. the index size and on levelStep.
714  * Note that a higher levelStep *reduces* the amount of memory needed for
715  * the hash table.
716  */
717  levelStep = 1;
718  for (;;)
719  {
720  double subtreesize;
721  double maxlowestlevelpages;
722 
723  /* size of an average subtree at this levelStep (in pages). */
724  subtreesize =
725  (1 - pow(avgIndexTuplesPerPage, (double) (levelStep + 1))) /
726  (1 - avgIndexTuplesPerPage);
727 
728  /* max number of pages at the lowest level of a subtree */
729  maxlowestlevelpages = pow(maxIndexTuplesPerPage, (double) levelStep);
730 
731  /* subtree must fit in cache (with safety factor of 4) */
732  if (subtreesize > effective_cache_size / 4)
733  break;
734 
735  /* each node in the lowest level of a subtree has one page in memory */
736  if (maxlowestlevelpages > ((double) maintenance_work_mem * 1024) / BLCKSZ)
737  break;
738 
739  /* Good, we can handle this levelStep. See if we can go one higher. */
740  levelStep++;
741  }
742 
743  /*
744  * We just reached an unacceptable value of levelStep in previous loop.
745  * So, decrease levelStep to get last acceptable value.
746  */
747  levelStep--;
748 
749  /*
750  * If there's not enough cache or maintenance_work_mem, fall back to plain
751  * inserts.
752  */
753  if (levelStep <= 0)
754  {
755  elog(DEBUG1, "failed to switch to buffered GiST build");
756  buildstate->buildMode = GIST_BUFFERING_DISABLED;
757  return;
758  }
759 
760  /*
761  * The second parameter to set is pagesPerBuffer, which determines the
762  * size of each buffer. We adjust pagesPerBuffer also during the build,
763  * which is why this calculation is in a separate function.
764  */
765  pagesPerBuffer = calculatePagesPerBuffer(buildstate, levelStep);
766 
767  /* Initialize GISTBuildBuffers with these parameters */
768  buildstate->gfbb = gistInitBuildBuffers(pagesPerBuffer, levelStep,
770 
771  gistInitParentMap(buildstate);
772 
773  buildstate->buildMode = GIST_BUFFERING_ACTIVE;
774 
775  elog(DEBUG1, "switched to buffered GiST build; level step = %d, pagesPerBuffer = %d",
776  levelStep, pagesPerBuffer);
777 }
#define MAXALIGN(LEN)
Definition: c.h:811
#define VARHDRSZ
Definition: c.h:692
static void gistInitParentMap(GISTBuildState *buildstate)
Definition: gistbuild.c:1514
static int gistGetMaxLevel(Relation index)
Definition: gistbuild.c:1425
GISTBuildBuffers * gistInitBuildBuffers(int pagesPerBuffer, int levelStep, int maxLevel)
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

References GISTBuildState::buildMode, calculatePagesPerBuffer(), DEBUG1, effective_cache_size, elog, GISTBuildState::freespace, GISTBuildState::gfbb, GIST_BUFFERING_ACTIVE, GIST_BUFFERING_DISABLED, gistGetMaxLevel(), gistInitBuildBuffers(), gistInitParentMap(), i, GISTBuildState::indexrel, GISTBuildState::indtuples, GISTBuildState::indtuplesSize, maintenance_work_mem, MAXALIGN, SizeOfPageHeaderData, TupleDescAttr, and VARHDRSZ.

Referenced by gistBuildCallback().

◆ gistInitParentMap()

static void gistInitParentMap ( GISTBuildState buildstate)
static

Definition at line 1514 of file gistbuild.c.

1515 {
1516  HASHCTL hashCtl;
1517 
1518  hashCtl.keysize = sizeof(BlockNumber);
1519  hashCtl.entrysize = sizeof(ParentMapEntry);
1520  hashCtl.hcxt = CurrentMemoryContext;
1521  buildstate->parentMap = hash_create("gistbuild parent map",
1522  1024,
1523  &hashCtl,
1525 }
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
MemoryContext hcxt
Definition: hsearch.h:86

References CurrentMemoryContext, HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, and GISTBuildState::parentMap.

Referenced by gistInitBuffering().

◆ gistMemorizeAllDownlinks()

static void gistMemorizeAllDownlinks ( GISTBuildState buildstate,
Buffer  parentbuf 
)
static

Definition at line 1544 of file gistbuild.c.

1545 {
1546  OffsetNumber maxoff;
1547  OffsetNumber off;
1548  BlockNumber parentblkno = BufferGetBlockNumber(parentbuf);
1549  Page page = BufferGetPage(parentbuf);
1550 
1551  Assert(!GistPageIsLeaf(page));
1552 
1553  maxoff = PageGetMaxOffsetNumber(page);
1554  for (off = FirstOffsetNumber; off <= maxoff; off++)
1555  {
1556  ItemId iid = PageGetItemId(page, off);
1557  IndexTuple idxtuple = (IndexTuple) PageGetItem(page, iid);
1558  BlockNumber childblkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
1559 
1560  gistMemorizeParent(buildstate, childblkno, parentblkno);
1561  }
1562 }

References Assert, BufferGetBlockNumber(), BufferGetPage(), FirstOffsetNumber, gistMemorizeParent(), GistPageIsLeaf, ItemPointerGetBlockNumber(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), and IndexTupleData::t_tid.

Referenced by gistbufferinginserttuples().

◆ gistMemorizeParent()

static void gistMemorizeParent ( GISTBuildState buildstate,
BlockNumber  child,
BlockNumber  parent 
)
static

Definition at line 1528 of file gistbuild.c.

1529 {
1530  ParentMapEntry *entry;
1531  bool found;
1532 
1533  entry = (ParentMapEntry *) hash_search(buildstate->parentMap,
1534  &child,
1535  HASH_ENTER,
1536  &found);
1537  entry->parentblkno = parent;
1538 }
@ HASH_ENTER
Definition: hsearch.h:114

References HASH_ENTER, hash_search(), GistSortedBuildLevelState::parent, ParentMapEntry::parentblkno, and GISTBuildState::parentMap.

Referenced by gistbufferinginserttuples(), gistMemorizeAllDownlinks(), and gistProcessItup().

◆ gistProcessEmptyingQueue()

static void gistProcessEmptyingQueue ( GISTBuildState buildstate)
static

Definition at line 1297 of file gistbuild.c.

1298 {
1299  GISTBuildBuffers *gfbb = buildstate->gfbb;
1300 
1301  /* Iterate while we have elements in buffers emptying stack. */
1302  while (gfbb->bufferEmptyingQueue != NIL)
1303  {
1304  GISTNodeBuffer *emptyingNodeBuffer;
1305 
1306  /* Get node buffer from emptying stack. */
1307  emptyingNodeBuffer = (GISTNodeBuffer *) linitial(gfbb->bufferEmptyingQueue);
1309  emptyingNodeBuffer->queuedForEmptying = false;
1310 
1311  /*
1312  * We are going to load last pages of buffers where emptying will be
1313  * to. So let's unload any previously loaded buffers.
1314  */
1315  gistUnloadNodeBuffers(gfbb);
1316 
1317  /*
1318  * Pop tuples from the buffer and run them down to the buffers at
1319  * lower level, or leaf pages. We continue until one of the lower
1320  * level buffers fills up, or this buffer runs empty.
1321  *
1322  * In Arge et al's paper, the buffer emptying is stopped after
1323  * processing 1/2 node buffer worth of tuples, to avoid overfilling
1324  * any of the lower level buffers. However, it's more efficient to
1325  * keep going until one of the lower level buffers actually fills up,
1326  * so that's what we do. This doesn't need to be exact, if a buffer
1327  * overfills by a few tuples, there's no harm done.
1328  */
1329  while (true)
1330  {
1331  IndexTuple itup;
1332 
1333  /* Get next index tuple from the buffer */
1334  if (!gistPopItupFromNodeBuffer(gfbb, emptyingNodeBuffer, &itup))
1335  break;
1336 
1337  /*
1338  * Run it down to the underlying node buffer or leaf page.
1339  *
1340  * Note: it's possible that the buffer we're emptying splits as a
1341  * result of this call. If that happens, our emptyingNodeBuffer
1342  * points to the left half of the split. After split, it's very
1343  * likely that the new left buffer is no longer over the half-full
1344  * threshold, but we might as well keep flushing tuples from it
1345  * until we fill a lower-level buffer.
1346  */
1347  if (gistProcessItup(buildstate, itup, emptyingNodeBuffer->nodeBlocknum, emptyingNodeBuffer->level))
1348  {
1349  /*
1350  * A lower level buffer filled up. Stop emptying this buffer,
1351  * to avoid overflowing the lower level buffer.
1352  */
1353  break;
1354  }
1355 
1356  /* Free all the memory allocated during index tuple processing */
1357  MemoryContextReset(buildstate->giststate->tempCxt);
1358  }
1359  }
1360 }
bool gistPopItupFromNodeBuffer(GISTBuildBuffers *gfbb, GISTNodeBuffer *nodeBuffer, IndexTuple *itup)
void gistUnloadNodeBuffers(GISTBuildBuffers *gfbb)
BlockNumber nodeBlocknum
Definition: gist_private.h:300

References GISTBuildBuffers::bufferEmptyingQueue, GISTBuildState::gfbb, gistPopItupFromNodeBuffer(), gistProcessItup(), GISTBuildState::giststate, gistUnloadNodeBuffers(), GISTNodeBuffer::level, linitial, list_delete_first(), MemoryContextReset(), NIL, GISTNodeBuffer::nodeBlocknum, GISTNodeBuffer::queuedForEmptying, and GISTSTATE::tempCxt.

Referenced by gistBufferingBuildInsert(), and gistEmptyAllBuffers().

◆ gistProcessItup()

static bool gistProcessItup ( GISTBuildState buildstate,
IndexTuple  itup,
BlockNumber  startblkno,
int  startlevel 
)
static

Definition at line 923 of file gistbuild.c.

925 {
926  GISTSTATE *giststate = buildstate->giststate;
927  GISTBuildBuffers *gfbb = buildstate->gfbb;
928  Relation indexrel = buildstate->indexrel;
929  BlockNumber childblkno;
930  Buffer buffer;
931  bool result = false;
932  BlockNumber blkno;
933  int level;
934  OffsetNumber downlinkoffnum = InvalidOffsetNumber;
935  BlockNumber parentblkno = InvalidBlockNumber;
936 
938 
939  /*
940  * Loop until we reach a leaf page (level == 0) or a level with buffers
941  * (not including the level we start at, because we would otherwise make
942  * no progress).
943  */
944  blkno = startblkno;
945  level = startlevel;
946  for (;;)
947  {
948  ItemId iid;
949  IndexTuple idxtuple,
950  newtup;
951  Page page;
952  OffsetNumber childoffnum;
953 
954  /* Have we reached a level with buffers? */
955  if (LEVEL_HAS_BUFFERS(level, gfbb) && level != startlevel)
956  break;
957 
958  /* Have we reached a leaf page? */
959  if (level == 0)
960  break;
961 
962  /*
963  * Nope. Descend down to the next level then. Choose a child to
964  * descend down to.
965  */
966 
967  buffer = ReadBuffer(indexrel, blkno);
968  LockBuffer(buffer, GIST_EXCLUSIVE);
969 
970  page = (Page) BufferGetPage(buffer);
971  childoffnum = gistchoose(indexrel, page, itup, giststate);
972  iid = PageGetItemId(page, childoffnum);
973  idxtuple = (IndexTuple) PageGetItem(page, iid);
974  childblkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
975 
976  if (level > 1)
977  gistMemorizeParent(buildstate, childblkno, blkno);
978 
979  /*
980  * Check that the key representing the target child node is consistent
981  * with the key we're inserting. Update it if it's not.
982  */
983  newtup = gistgetadjusted(indexrel, idxtuple, itup, giststate);
984  if (newtup)
985  {
986  blkno = gistbufferinginserttuples(buildstate,
987  buffer,
988  level,
989  &newtup,
990  1,
991  childoffnum,
994  /* gistbufferinginserttuples() released the buffer */
995  }
996  else
997  UnlockReleaseBuffer(buffer);
998 
999  /* Descend to the child */
1000  parentblkno = blkno;
1001  blkno = childblkno;
1002  downlinkoffnum = childoffnum;
1003  Assert(level > 0);
1004  level--;
1005  }
1006 
1007  if (LEVEL_HAS_BUFFERS(level, gfbb))
1008  {
1009  /*
1010  * We've reached level with buffers. Place the index tuple to the
1011  * buffer, and add the buffer to the emptying queue if it overflows.
1012  */
1013  GISTNodeBuffer *childNodeBuffer;
1014 
1015  /* Find the buffer or create a new one */
1016  childNodeBuffer = gistGetNodeBuffer(gfbb, giststate, blkno, level);
1017 
1018  /* Add index tuple to it */
1019  gistPushItupToNodeBuffer(gfbb, childNodeBuffer, itup);
1020 
1021  if (BUFFER_OVERFLOWED(childNodeBuffer, gfbb))
1022  result = true;
1023  }
1024  else
1025  {
1026  /*
1027  * We've reached a leaf page. Place the tuple here.
1028  */
1029  Assert(level == 0);
1030  buffer = ReadBuffer(indexrel, blkno);
1031  LockBuffer(buffer, GIST_EXCLUSIVE);
1032  gistbufferinginserttuples(buildstate, buffer, level,
1033  &itup, 1, InvalidOffsetNumber,
1034  parentblkno, downlinkoffnum);
1035  /* gistbufferinginserttuples() released the buffer */
1036  }
1037 
1038  return result;
1039 }
#define LEVEL_HAS_BUFFERS(nlevel, gfbb)
Definition: gist_private.h:319
#define BUFFER_OVERFLOWED(nodeBuffer, gfbb)
Definition: gist_private.h:332
void gistPushItupToNodeBuffer(GISTBuildBuffers *gfbb, GISTNodeBuffer *nodeBuffer, IndexTuple itup)
GISTNodeBuffer * gistGetNodeBuffer(GISTBuildBuffers *gfbb, GISTSTATE *giststate, BlockNumber nodeBlocknum, int level)
IndexTuple gistgetadjusted(Relation r, IndexTuple oldtup, IndexTuple addtup, GISTSTATE *giststate)
Definition: gistutil.c:315
OffsetNumber gistchoose(Relation r, Page p, IndexTuple it, GISTSTATE *giststate)
Definition: gistutil.c:373

References Assert, BUFFER_OVERFLOWED, BufferGetPage(), CHECK_FOR_INTERRUPTS, GISTBuildState::gfbb, GIST_EXCLUSIVE, gistbufferinginserttuples(), gistchoose(), gistgetadjusted(), gistGetNodeBuffer(), gistMemorizeParent(), gistPushItupToNodeBuffer(), GISTBuildState::giststate, GISTBuildState::indexrel, InvalidBlockNumber, InvalidOffsetNumber, ItemPointerGetBlockNumber(), LEVEL_HAS_BUFFERS, LockBuffer(), PageGetItem(), PageGetItemId(), ReadBuffer(), IndexTupleData::t_tid, and UnlockReleaseBuffer().

Referenced by gistBufferingBuildInsert(), and gistProcessEmptyingQueue().

◆ gistSortedBuildCallback()

static void gistSortedBuildCallback ( Relation  index,
ItemPointer  tid,
Datum values,
bool isnull,
bool  tupleIsAlive,
void *  state 
)
static

Definition at line 366 of file gistbuild.c.

372 {
373  GISTBuildState *buildstate = (GISTBuildState *) state;
374  MemoryContext oldCtx;
375  Datum compressed_values[INDEX_MAX_KEYS];
376 
377  oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
378 
379  /* Form an index tuple and point it at the heap tuple */
380  gistCompressValues(buildstate->giststate, index,
381  values, isnull,
382  true, compressed_values);
383 
385  buildstate->indexrel,
386  tid,
387  compressed_values, isnull);
388 
389  MemoryContextSwitchTo(oldCtx);
390  MemoryContextReset(buildstate->giststate->tempCxt);
391 
392  /* Update tuple count. */
393  buildstate->indtuples += 1;
394 }
void gistCompressValues(GISTSTATE *giststate, Relation r, const Datum *attdata, const bool *isnull, bool isleaf, Datum *compatt)
Definition: gistutil.c:595
uintptr_t Datum
Definition: postgres.h:64
void tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel, ItemPointer self, const Datum *values, const bool *isnull)

References gistCompressValues(), GISTBuildState::giststate, INDEX_MAX_KEYS, GISTBuildState::indexrel, GISTBuildState::indtuples, MemoryContextReset(), MemoryContextSwitchTo(), GISTBuildState::sortstate, GISTSTATE::tempCxt, tuplesort_putindextuplevalues(), and values.

Referenced by gistbuild().