/*
* Process an index tuple. Runs the tuple down the tree until we reach a leaf
* page or node buffer, and inserts the tuple there. Returns true if we have
* to stop buffer emptying process (because one of child buffers can't take
* index tuples anymore).
*/
static bool
gistProcessItup(GISTBuildState *buildstate, IndexTuple itup,
GISTBufferingInsertStack *startparent)
{
GISTSTATE *giststate = buildstate->giststate;
GISTBuildBuffers *gfbb = buildstate->gfbb;
Relation indexrel = buildstate->indexrel;
GISTBufferingInsertStack *path;
BlockNumber childblkno;
Buffer buffer;
bool result = false;
/*
* NULL passed in startparent means that we start index tuple processing
* from the root.
*/
if (!startparent)
path = gfbb->rootitem;
else
path = startparent;
/*
* Loop until we reach a leaf page (level == 0) or a level with buffers
* (not including the level we start at, because we would otherwise make
* no progress).
*/
for (;;)
{
ItemId iid;
IndexTuple idxtuple,
newtup;
Page page;
OffsetNumber childoffnum;
GISTBufferingInsertStack *parent;
/* Have we reached a level with buffers? */
if (LEVEL_HAS_BUFFERS(path->level, gfbb) && path != startparent)
break;
/* Have we reached a leaf page? */
if (path->level == 0)
break;
/*
* Nope. Descend down to the next level then. Choose a child to
* descend down to.
*/
buffer = ReadBuffer(indexrel, path->blkno);
LockBuffer(buffer, GIST_EXCLUSIVE);
page = (Page) BufferGetPage(buffer);
childoffnum = gistchoose(indexrel, page, itup, giststate);
iid = PageGetItemId(page, childoffnum);
idxtuple = (IndexTuple) PageGetItem(page, iid);
childblkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
/*
* Check that the key representing the target child node is consistent
* with the key we're inserting. Update it if it's not.
*/
newtup = gistgetadjusted(indexrel, idxtuple, itup, giststate);
if (newtup)
gistbufferinginserttuples(buildstate, buffer, &newtup, 1,
childoffnum, path);
UnlockReleaseBuffer(buffer);
/* Create new path item representing current page */
parent = path;
path = (GISTBufferingInsertStack *) MemoryContextAlloc(gfbb->context,
sizeof(GISTBufferingInsertStack));
path->parent = parent;
path->level = parent->level - 1;
path->blkno = childblkno;
path->downlinkoffnum = childoffnum;
path->refCount = 0; /* it's unreferenced for now */
/* Adjust reference count of parent */
if (parent)
parent->refCount++;
}
if (LEVEL_HAS_BUFFERS(path->level, gfbb))
{
/*
* We've reached level with buffers. Place the index tuple to the
* buffer, and add the buffer to the emptying queue if it overflows.
*/
GISTNodeBuffer *childNodeBuffer;
/* Find the buffer or create a new one */
childNodeBuffer = gistGetNodeBuffer(gfbb, giststate, path->blkno,
path->downlinkoffnum, path->parent);
/* Add index tuple to it */
gistPushItupToNodeBuffer(gfbb, childNodeBuffer, itup);
if (BUFFER_OVERFLOWED(childNodeBuffer, gfbb))
result = true;
}
else
{
/*
* We've reached a leaf page. Place the tuple here.
*/
buffer = ReadBuffer(indexrel, path->blkno);
LockBuffer(buffer, GIST_EXCLUSIVE);
gistbufferinginserttuples(buildstate, buffer, &itup, 1,
InvalidOffsetNumber, path);
UnlockReleaseBuffer(buffer);
}
/*
* Free unreferenced path items, if any. Path item may be referenced by
* node buffer.
*/
gistFreeUnreferencedPath(path);
return result;
}
/*
* Process an index tuple. Runs the tuple down the tree until we reach a leaf
* page or node buffer, and inserts the tuple there. Returns true if we have
* to stop buffer emptying process (because one of child buffers can't take
* index tuples anymore).
*/
static bool
gistProcessItup(GISTBuildState *buildstate, IndexTuple itup,
BlockNumber startblkno, int startlevel)
{
GISTSTATE *giststate = buildstate->giststate;
GISTBuildBuffers *gfbb = buildstate->gfbb;
Relation indexrel = buildstate->indexrel;
BlockNumber childblkno;
Buffer buffer;
bool result = false;
BlockNumber blkno;
int level;
OffsetNumber downlinkoffnum = InvalidOffsetNumber;
BlockNumber parentblkno = InvalidBlockNumber;
CHECK_FOR_INTERRUPTS();
/*
* Loop until we reach a leaf page (level == 0) or a level with buffers
* (not including the level we start at, because we would otherwise make
* no progress).
*/
blkno = startblkno;
level = startlevel;
for (;;)
{
ItemId iid;
IndexTuple idxtuple,
newtup;
Page page;
OffsetNumber childoffnum;
/* Have we reached a level with buffers? */
if (LEVEL_HAS_BUFFERS(level, gfbb) && level != startlevel)
break;
/* Have we reached a leaf page? */
if (level == 0)
break;
/*
* Nope. Descend down to the next level then. Choose a child to
* descend down to.
*/
buffer = ReadBuffer(indexrel, blkno);
LockBuffer(buffer, GIST_EXCLUSIVE);
page = (Page) BufferGetPage(buffer);
childoffnum = gistchoose(indexrel, page, itup, giststate);
iid = PageGetItemId(page, childoffnum);
idxtuple = (IndexTuple) PageGetItem(page, iid);
childblkno = ItemPointerGetBlockNumber(&(idxtuple->t_tid));
if (level > 1)
gistMemorizeParent(buildstate, childblkno, blkno);
/*
* Check that the key representing the target child node is consistent
* with the key we're inserting. Update it if it's not.
*/
newtup = gistgetadjusted(indexrel, idxtuple, itup, giststate);
if (newtup)
{
blkno = gistbufferinginserttuples(buildstate, buffer, level,
&newtup, 1, childoffnum,
InvalidBlockNumber, InvalidOffsetNumber);
/* gistbufferinginserttuples() released the buffer */
}
else
UnlockReleaseBuffer(buffer);
/* Descend to the child */
parentblkno = blkno;
blkno = childblkno;
downlinkoffnum = childoffnum;
Assert(level > 0);
level--;
}
if (LEVEL_HAS_BUFFERS(level, gfbb))
{
/*
* We've reached level with buffers. Place the index tuple to the
* buffer, and add the buffer to the emptying queue if it overflows.
*/
GISTNodeBuffer *childNodeBuffer;
/* Find the buffer or create a new one */
childNodeBuffer = gistGetNodeBuffer(gfbb, giststate, blkno, level);
/* Add index tuple to it */
gistPushItupToNodeBuffer(gfbb, childNodeBuffer, itup);
if (BUFFER_OVERFLOWED(childNodeBuffer, gfbb))
result = true;
}
else
{
/*
* We've reached a leaf page. Place the tuple here.
*/
Assert(level == 0);
buffer = ReadBuffer(indexrel, blkno);
LockBuffer(buffer, GIST_EXCLUSIVE);
gistbufferinginserttuples(buildstate, buffer, level,
&itup, 1, InvalidOffsetNumber,
parentblkno, downlinkoffnum);
/* gistbufferinginserttuples() released the buffer */
}
return result;
}
/*
* At page split, distribute tuples from the buffer of the split page to
* new buffers for the created page halves. This also adjusts the downlinks
* in 'splitinfo' to include the tuples in the buffers.
*/
void
gistRelocateBuildBuffersOnSplit(GISTBuildBuffers *gfbb, GISTSTATE *giststate,
Relation r, int level,
Buffer buffer, List *splitinfo)
{
RelocationBufferInfo *relocationBuffersInfos;
bool found;
GISTNodeBuffer *nodeBuffer;
BlockNumber blocknum;
IndexTuple itup;
int splitPagesCount = 0,
i;
GISTENTRY entry[INDEX_MAX_KEYS];
bool isnull[INDEX_MAX_KEYS];
GISTNodeBuffer oldBuf;
ListCell *lc;
/* If the splitted page doesn't have buffers, we have nothing to do. */
if (!LEVEL_HAS_BUFFERS(level, gfbb))
return;
/*
* Get the node buffer of the splitted page.
*/
blocknum = BufferGetBlockNumber(buffer);
nodeBuffer = hash_search(gfbb->nodeBuffersTab, &blocknum,
HASH_FIND, &found);
if (!found)
{
/* The page has no buffer, so we have nothing to do. */
return;
}
/*
* Make a copy of the old buffer, as we're going reuse it as the buffer
* for the new left page, which is on the same block as the old page.
* That's not true for the root page, but that's fine because we never
* have a buffer on the root page anyway. The original algorithm as
* described by Arge et al did, but it's of no use, as you might as well
* read the tuples straight from the heap instead of the root buffer.
*/
Assert(blocknum != GIST_ROOT_BLKNO);
memcpy(&oldBuf, nodeBuffer, sizeof(GISTNodeBuffer));
oldBuf.isTemp = true;
/* Reset the old buffer, used for the new left page from now on */
nodeBuffer->blocksCount = 0;
nodeBuffer->pageBuffer = NULL;
nodeBuffer->pageBlocknum = InvalidBlockNumber;
/*
* Allocate memory for information about relocation buffers.
*/
splitPagesCount = list_length(splitinfo);
relocationBuffersInfos =
(RelocationBufferInfo *) palloc(sizeof(RelocationBufferInfo) *
splitPagesCount);
/*
* Fill relocation buffers information for node buffers of pages produced
* by split.
*/
i = 0;
foreach(lc, splitinfo)
{
GISTPageSplitInfo *si = (GISTPageSplitInfo *) lfirst(lc);
GISTNodeBuffer *newNodeBuffer;
/* Decompress parent index tuple of node buffer page. */
gistDeCompressAtt(giststate, r,
si->downlink, NULL, (OffsetNumber) 0,
relocationBuffersInfos[i].entry,
relocationBuffersInfos[i].isnull);
/*
* Create a node buffer for the page. The leftmost half is on the same
* block as the old page before split, so for the leftmost half this
* will return the original buffer. The tuples on the original buffer
* were relinked to the temporary buffer, so the original one is now
* empty.
*/
newNodeBuffer = gistGetNodeBuffer(gfbb, giststate, BufferGetBlockNumber(si->buf), level);
relocationBuffersInfos[i].nodeBuffer = newNodeBuffer;
relocationBuffersInfos[i].splitinfo = si;
i++;
}