*/
metaBuffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
LockBuffer(metaBuffer, BUFFER_LOCK_SHARE);
- metaData = BloomPageGetMeta(BufferGetPage(metaBuffer));
+ metaData = BloomPageGetMeta(BufferGetPage(metaBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
if (metaData->nEnd > metaData->nStart)
{
blkno, RBM_NORMAL, bas);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!BloomPageIsDeleted(page))
{
buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!BloomPageIsMeta(page))
elog(ERROR, "Relation is not a bloom index");
- meta = BloomPageGetMeta(BufferGetPage(buffer));
+ meta = BloomPageGetMeta(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
if (meta->magickNumber != BLOOM_MAGICK_NUMBER)
elog(ERROR, "Relation is not a bloom index");
*/
if (ConditionalLockBuffer(buffer))
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
return buffer; /* OK to use, if never initialized */
buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
RBM_NORMAL, info->strategy);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (BloomPageIsDeleted(page))
{
static void
GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageHeader phdr = (PageHeader) page;
OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
BTPageOpaque opaque = (BTPageOpaque) PageGetSpecialPointer(page);
uargs = palloc(sizeof(struct user_args));
uargs->page = palloc(BLCKSZ);
- memcpy(uargs->page, BufferGetPage(buffer), BLCKSZ);
+ memcpy(uargs->page,
+ BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BLCKSZ);
UnlockReleaseBuffer(buffer);
relation_close(rel, AccessShareLock);
buffer = ReadBuffer(rel, 0);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metad = BTPageGetMeta(page);
/* Build a tuple descriptor for our result type */
buf = ReadBufferExtended(rel, forknum, blkno, RBM_NORMAL, NULL);
LockBuffer(buf, BUFFER_LOCK_SHARE);
- memcpy(raw_page_data, BufferGetPage(buf), BLCKSZ);
+ memcpy(raw_page_data,
+ BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BLCKSZ);
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buf);
buffer = ReadBuffer(rel, blkno);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
values[2] = BoolGetDatum(PageIsAllVisible(page));
UnlockReleaseBuffer(buffer);
bstrategy);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsAllVisible(page))
info->bits[blkno] |= (1 << 2);
LockBuffer(buf, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* It's not safe to call PageGetHeapFreeSpace() on new pages, so we
*/
{
Buffer buffer = ReadBufferExtended(rel, MAIN_FORKNUM, 0, RBM_NORMAL, bstrategy);
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTMetaPageData *metad = BTPageGetMeta(page);
indexStat.version = metad->btm_version;
buffer = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL, bstrategy);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
/* Determine page type, and update totals */
*/
buffer = ReadBuffer(rel, GIN_METAPAGE_BLKNO);
LockBuffer(buffer, GIN_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = GinPageGetMeta(page);
stats.version = metadata->ginVersion;
buffer = ReadBufferExtended(rel, MAIN_FORKNUM, block,
RBM_NORMAL, scan->rs_strategy);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- stat.free_space += PageGetHeapFreeSpace((Page) BufferGetPage(buffer));
+ stat.free_space += PageGetHeapFreeSpace
+ (BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
UnlockReleaseBuffer(buffer);
block++;
}
buffer = ReadBufferExtended(rel, MAIN_FORKNUM, block,
RBM_NORMAL, scan->rs_strategy);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- stat.free_space += PageGetHeapFreeSpace((Page) BufferGetPage(buffer));
+ stat.free_space += PageGetHeapFreeSpace
+ (BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
UnlockReleaseBuffer(buffer);
block++;
}
buf = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL, bstrategy);
LockBuffer(buf, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* Page is valid, see what to do with it */
if (PageIsNew(page))
_hash_getlock(rel, blkno, HASH_SHARE);
buf = _hash_getbuf_with_strategy(rel, blkno, HASH_READ, 0, bstrategy);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageGetSpecialSize(page) == MAXALIGN(sizeof(HashPageOpaqueData)))
{
buf = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL, bstrategy);
LockBuffer(buf, GIST_SHARE);
gistcheckpage(rel, buf);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GistPageIsLeaf(page))
{
}
else
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
ItemId lp = PageGetItemId(page, off);
Size origsz;
BrinTuple *origtup;
Assert(BufferGetBlockNumber(meta) == BRIN_METAPAGE_BLKNO);
LockBuffer(meta, BUFFER_LOCK_EXCLUSIVE);
- brin_metapage_init(BufferGetPage(meta), BrinGetPagesPerRange(index),
+ brin_metapage_init(BufferGetPage(meta, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BrinGetPagesPerRange(index),
BRIN_CURRENT_VERSION);
MarkBufferDirty(meta);
recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
- page = BufferGetPage(meta);
+ page = BufferGetPage(meta, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
/* Initialize and xlog metabuffer. */
START_CRIT_SECTION();
- brin_metapage_init(BufferGetPage(metabuf), BrinGetPagesPerRange(index),
+ brin_metapage_init(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ BrinGetPagesPerRange(index),
BRIN_CURRENT_VERSION);
MarkBufferDirty(metabuf);
log_newpage_buffer(metabuf, false);
{
Page page;
- page = BufferGetPage(state->bs_currentInsertBuf);
+ page = BufferGetPage(state->bs_currentInsertBuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
RecordPageWithFreeSpace(state->bs_irel,
BufferGetBlockNumber(state->bs_currentInsertBuf),
PageGetFreeSpace(page));
newbuf = InvalidBuffer;
extended = false;
}
- oldpage = BufferGetPage(oldbuf);
+ oldpage = BufferGetPage(oldbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
oldlp = PageGetItemId(oldpage, oldoff);
/*
* Not enough free space on the oldpage. Put the new tuple on the new
* page, and update the revmap.
*/
- Page newpage = BufferGetPage(newbuf);
+ Page newpage = BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
Buffer revmapbuf;
ItemPointerData newtid;
OffsetNumber newoff;
* need to do that here.
*/
if (extended)
- brin_page_init(BufferGetPage(newbuf), BRIN_PAGETYPE_REGULAR);
+ brin_page_init(BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ BRIN_PAGETYPE_REGULAR);
PageIndexDeleteNoCompact(oldpage, &oldoff, 1);
newoff = PageAddItem(newpage, (Item) newtup, newsz,
PageSetLSN(oldpage, recptr);
PageSetLSN(newpage, recptr);
- PageSetLSN(BufferGetPage(revmapbuf), recptr);
+ PageSetLSN(BufferGetPage(revmapbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ recptr);
}
END_CRIT_SECTION();
{
return
((newsz <= origsz) ||
- PageGetExactFreeSpace(BufferGetPage(buffer)) >= (newsz - origsz));
+ PageGetExactFreeSpace(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST))
+ >= (newsz - origsz));
}
/*
* it's still a regular page.
*/
LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
- if (br_page_get_freespace(BufferGetPage(*buffer)) < itemsz)
+ if (br_page_get_freespace(BufferGetPage(*buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST))
+ < itemsz)
{
UnlockReleaseBuffer(*buffer);
*buffer = InvalidBuffer;
/* Now obtain lock on revmap buffer */
revmapbuf = brinLockRevmapPageForUpdate(revmap, heapBlk);
- page = BufferGetPage(*buffer);
+ page = BufferGetPage(*buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
blk = BufferGetBlockNumber(*buffer);
/* Execute the actual insertion */
START_CRIT_SECTION();
if (extended)
- brin_page_init(BufferGetPage(*buffer), BRIN_PAGETYPE_REGULAR);
+ brin_page_init(BufferGetPage(*buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ BRIN_PAGETYPE_REGULAR);
off = PageAddItem(page, (Item) tup, itemsz, InvalidOffsetNumber,
false, false);
if (off == InvalidOffsetNumber)
recptr = XLogInsert(RM_BRIN_ID, info);
PageSetLSN(page, recptr);
- PageSetLSN(BufferGetPage(revmapbuf), recptr);
+ PageSetLSN(BufferGetPage(revmapbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
END_CRIT_SECTION();
OffsetNumber maxoff;
Page page;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
return false;
OffsetNumber maxoff;
Page page;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(BrinPageFlags(page) & BRIN_EVACUATE_PAGE);
bool
brin_page_cleanup(Relation idxrel, Buffer buf)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Size freespace;
/*
}
/* Nothing to be done for non-regular index pages */
- if (BRIN_IS_META_PAGE(BufferGetPage(buf)) ||
- BRIN_IS_REVMAP_PAGE(BufferGetPage(buf)))
+ if (BRIN_IS_META_PAGE(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)) ||
+ BRIN_IS_REVMAP_PAGE(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
return false;
/* Measure free space and record it */
if (BufferIsValid(oldbuf) && oldblk < newblk)
{
LockBuffer(oldbuf, BUFFER_LOCK_EXCLUSIVE);
- if (!BRIN_IS_REGULAR_PAGE(BufferGetPage(oldbuf)))
+ if (!BRIN_IS_REGULAR_PAGE(BufferGetPage(oldbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
{
LockBuffer(oldbuf, BUFFER_LOCK_UNLOCK);
if (extensionLockHeld)
UnlockRelationForExtension(irel, ExclusiveLock);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* We have a new buffer to insert into. Check that the new page has
if (BufferIsValid(oldbuf) && oldblk > newblk)
{
LockBuffer(oldbuf, BUFFER_LOCK_EXCLUSIVE);
- Assert(BRIN_IS_REGULAR_PAGE(BufferGetPage(oldbuf)));
+ Assert(BRIN_IS_REGULAR_PAGE(BufferGetPage(oldbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)));
}
return buf;
BufferGetBlockNumber(buffer)));
START_CRIT_SECTION();
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
brin_page_init(page, BRIN_PAGETYPE_REGULAR);
MarkBufferDirty(buffer);
log_newpage_buffer(buffer, true);
BrinRevmap *revmap;
Buffer meta;
BrinMetaPageData *metadata;
+ Page page;
meta = ReadBuffer(idxrel, BRIN_METAPAGE_BLKNO);
LockBuffer(meta, BUFFER_LOCK_SHARE);
- metadata = (BrinMetaPageData *) PageGetContents(BufferGetPage(meta));
+ page = BufferGetPage(meta, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
+ metadata = (BrinMetaPageData *) PageGetContents(page);
revmap = palloc(sizeof(BrinRevmap));
revmap->rm_irel = idxrel;
Page page;
/* The correct page should already be pinned and locked */
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
contents = (RevmapContents *) PageGetContents(page);
iptr = (ItemPointerData *) contents->rm_tids;
iptr += HEAPBLK_TO_REVMAP_INDEX(pagesPerRange, heapBlk);
LockBuffer(revmap->rm_currBuf, BUFFER_LOCK_SHARE);
contents = (RevmapContents *)
- PageGetContents(BufferGetPage(revmap->rm_currBuf));
+ PageGetContents(BufferGetPage(revmap->rm_currBuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
iptr = contents->rm_tids;
iptr += HEAPBLK_TO_REVMAP_INDEX(revmap->rm_pagesPerRange, heapBlk);
*buf = ReadBuffer(idxRel, blk);
}
LockBuffer(*buf, mode);
- page = BufferGetPage(*buf);
+ page = BufferGetPage(*buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* If we land on a revmap page, start over */
if (BRIN_IS_REGULAR_PAGE(page))
* another backend can extend the index with regular BRIN pages.
*/
LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_EXCLUSIVE);
- metapage = BufferGetPage(revmap->rm_metaBuf);
+ metapage = BufferGetPage(revmap->rm_metaBuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
metadata = (BrinMetaPageData *) PageGetContents(metapage);
/*
{
buf = ReadBuffer(irel, mapBlk);
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
else
{
return;
}
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (needLock)
UnlockRelationForExtension(irel, ExclusiveLock);
/* create the index' metapage */
buf = XLogInitBufferForRedo(record, 0);
Assert(BufferIsValid(buf));
- page = (Page) BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
brin_metapage_init(page, xlrec->pagesPerRange, xlrec->version);
PageSetLSN(page, lsn);
MarkBufferDirty(buf);
if (XLogRecGetInfo(record) & XLOG_BRIN_INIT_PAGE)
{
buffer = XLogInitBufferForRedo(record, 0);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
brin_page_init(page, BRIN_PAGETYPE_REGULAR);
action = BLK_NEEDS_REDO;
}
Assert(tuple->bt_blkno == xlrec->heapBlk);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) + 1 < offnum)
elog(PANIC, "brin_xlog_insert_update: invalid max offset number");
ItemPointerData tid;
ItemPointerSet(&tid, regpgno, xlrec->offnum);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
brinSetHeapBlockItemptr(buffer, xlrec->pagesPerRange, xlrec->heapBlk,
tid);
Page page;
OffsetNumber offnum;
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->oldOffnum;
if (PageGetMaxOffsetNumber(page) + 1 < offnum)
brintuple = (BrinTuple *) XLogRecGetBlockData(record, 0, &tuplen);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) + 1 < offnum)
Page metapg;
BrinMetaPageData *metadata;
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = (BrinMetaPageData *) PageGetContents(metapg);
Assert(metadata->lastRevmapPage == xlrec->targetBlk - 1);
*/
buf = XLogInitBufferForRedo(record, 1);
- page = (Page) BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
brin_page_init(page, BRIN_PAGETYPE_REVMAP);
PageSetLSN(page, lsn);
int access = GIN_SHARE;
LockBuffer(buffer, GIN_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GinPageIsLeaf(page))
{
if (searchMode == FALSE)
stack->off = InvalidOffsetNumber;
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
access = ginTraverseLock(stack->buffer, searchMode);
stack->buffer = ginStepRight(stack->buffer, btree->index, access);
stack->blkno = rightlink;
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (!searchMode && GinPageIsIncompleteSplit(page))
ginFinishSplit(btree, stack, false, NULL);
ginStepRight(Buffer buffer, Relation index, int lockmode)
{
Buffer nextbuffer;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
bool isLeaf = GinPageIsLeaf(page);
bool isData = GinPageIsData(page);
BlockNumber blkno = GinPageGetOpaque(page)->rightlink;
UnlockReleaseBuffer(buffer);
/* Sanity check that the page we stepped to is of similar kind. */
- page = BufferGetPage(nextbuffer);
+ page = BufferGetPage(nextbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (isLeaf != GinPageIsLeaf(page) || isData != GinPageIsData(page))
elog(ERROR, "right sibling of GIN page is of different type");
for (;;)
{
LockBuffer(buffer, GIN_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GinPageIsLeaf(page))
elog(ERROR, "Lost path");
break;
}
buffer = ginStepRight(buffer, btree->index, GIN_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* finish any incomplete splits, as above */
if (GinPageIsIncompleteSplit(page))
void *insertdata, BlockNumber updateblkno,
Buffer childbuf, GinStatsData *buildStats)
{
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
GinPlaceToPageRC rc;
uint16 xlflags = 0;
Page childpage = NULL;
{
Assert(BufferIsValid(childbuf));
Assert(updateblkno != InvalidBlockNumber);
- childpage = BufferGetPage(childbuf);
+ childpage = BufferGetPage(childbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
/*
data.flags = xlflags;
if (childbuf != InvalidBuffer)
{
- Page childpage = BufferGetPage(childbuf);
+ Page childpage = BufferGetPage(childbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
GinPageGetOpaque(childpage)->flags &= ~GIN_INCOMPLETE_SPLIT;
if (stack->parent == NULL)
{
MarkBufferDirty(lbuffer);
- memcpy(BufferGetPage(stack->buffer), newrootpg, BLCKSZ);
- memcpy(BufferGetPage(lbuffer), newlpage, BLCKSZ);
- memcpy(BufferGetPage(rbuffer), newrpage, BLCKSZ);
+ memcpy(BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ newrootpg, BLCKSZ);
+ memcpy(BufferGetPage(lbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ newlpage, BLCKSZ);
+ memcpy(BufferGetPage(rbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ newrpage, BLCKSZ);
}
else
{
- memcpy(BufferGetPage(stack->buffer), newlpage, BLCKSZ);
- memcpy(BufferGetPage(rbuffer), newrpage, BLCKSZ);
+ memcpy(BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ newlpage, BLCKSZ);
+ memcpy(BufferGetPage(rbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ newrpage, BLCKSZ);
}
/* write WAL record */
XLogRegisterData((char *) &data, sizeof(ginxlogSplit));
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_SPLIT);
- PageSetLSN(BufferGetPage(stack->buffer), recptr);
- PageSetLSN(BufferGetPage(rbuffer), recptr);
+ PageSetLSN(BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ recptr);
+ PageSetLSN(BufferGetPage(rbuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ recptr);
if (stack->parent == NULL)
- PageSetLSN(BufferGetPage(lbuffer), recptr);
+ PageSetLSN(BufferGetPage(lbuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ recptr);
if (BufferIsValid(childbuf))
PageSetLSN(childpage, recptr);
}
* page that has no downlink in the parent, and splitting it further
* would fail.
*/
- if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer)))
+ if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
ginFinishSplit(btree, parent, false, buildStats);
/* move right if it's needed */
- page = BufferGetPage(parent->buffer);
+ page = BufferGetPage(parent->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
while ((parent->off = btree->findChildPtr(btree, page, stack->blkno, parent->off)) == InvalidOffsetNumber)
{
if (GinPageRightMost(page))
parent->buffer = ginStepRight(parent->buffer, btree->index, GIN_EXCLUSIVE);
parent->blkno = BufferGetBlockNumber(parent->buffer);
- page = BufferGetPage(parent->buffer);
+ page = BufferGetPage(parent->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
- if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer)))
+ if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
ginFinishSplit(btree, parent, false, buildStats);
}
/* insert the downlink */
insertdata = btree->prepareDownlink(btree, stack->buffer);
- updateblkno = GinPageGetOpaque(BufferGetPage(stack->buffer))->rightlink;
+ updateblkno = GinPageGetOpaque(BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST))->rightlink;
done = ginPlaceToPage(btree, parent,
insertdata, updateblkno,
stack->buffer, buildStats);
bool done;
/* If the leaf page was incompletely split, finish the split first */
- if (GinPageIsIncompleteSplit(BufferGetPage(stack->buffer)))
+ if (GinPageIsIncompleteSplit(BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
ginFinishSplit(btree, stack, false, buildStats);
done = ginPlaceToPage(btree, stack,
maxoff;
PostingItem *pitem = NULL;
int result;
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(!GinPageIsLeaf(page));
Assert(GinPageIsData(page));
GinBtreeDataLeafInsertData *items = insertdata;
ItemPointer newItems = &items->items[items->curitem];
int maxitems = items->nitem - items->curitem;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
int i;
ItemPointerData rbound;
ItemPointerData lbound;
void
ginVacuumPostingTreeLeaf(Relation indexrel, Buffer buffer, GinVacuumState *gvs)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
disassembledLeaf *leaf;
bool removedsomething = false;
dlist_iter iter;
static void
dataPlaceToPageLeafRecompress(Buffer buf, disassembledLeaf *leaf)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
char *ptr;
int newsize;
bool modified = false;
void *insertdata, BlockNumber updateblkno,
Page *newlpage, Page *newrpage)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber off = stack->off;
PostingItem *pitem;
void *insertdata, BlockNumber updateblkno,
Page *newlpage, Page *newrpage)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageIsData(page));
void *insertdata, BlockNumber updateblkno,
Page *newlpage, Page *newrpage)
{
- Page oldpage = BufferGetPage(origbuf);
+ Page oldpage = BufferGetPage(origbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber off = stack->off;
int nitems = GinPageGetOpaque(oldpage)->maxoff;
int nleftitems;
dataPrepareDownlink(GinBtree btree, Buffer lbuf)
{
PostingItem *pitem = palloc(sizeof(PostingItem));
- Page lpage = BufferGetPage(lbuf);
+ Page lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PostingItemSetBlockNumber(pitem, BufferGetBlockNumber(lbuf));
pitem->key = *GinDataPageGetRightBound(lpage);
* All set. Get a new physical page, and copy the in-memory page to it.
*/
buffer = GinNewBuffer(index);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
blkno = BufferGetBlockNumber(buffer);
START_CRIT_SECTION();
maxoff;
IndexTuple itup = NULL;
int result;
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
Assert(!GinPageIsLeaf(page));
Assert(!GinPageIsData(page));
static bool
entryLocateLeafEntry(GinBtree btree, GinBtreeStack *stack)
{
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
OffsetNumber low,
high;
{
Size releasedsz = 0;
Size addedsz;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(insertData->entry);
Assert(!GinPageIsData(page));
Page *newlpage, Page *newrpage)
{
GinBtreeEntryInsertData *insertData = insertPayload;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber off = stack->off;
OffsetNumber placed;
char *ptr;
IndexTuple itup;
Page page;
- Page lpage = PageGetTempPageCopy(BufferGetPage(origbuf));
- Page rpage = PageGetTempPageCopy(BufferGetPage(origbuf));
+ Page lpage = PageGetTempPageCopy(BufferGetPage(origbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
+ Page rpage = PageGetTempPageCopy(BufferGetPage(origbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
Size pageSize = PageGetPageSize(lpage);
char tupstore[2 * BLCKSZ];
entryPrepareDownlink(GinBtree btree, Buffer lbuf)
{
GinBtreeEntryInsertData *insertData;
- Page lpage = BufferGetPage(lbuf);
+ Page lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BlockNumber lblkno = BufferGetBlockNumber(lbuf);
IndexTuple itup;
writeListPage(Relation index, Buffer buffer,
IndexTuple *tuples, int32 ntuples, BlockNumber rightlink)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
int32 i,
freesize,
size = 0;
data.newRightlink = data.prevTail = InvalidBlockNumber;
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GinListPageSize)
{
buffer = ReadBuffer(index, metadata->tail);
LockBuffer(buffer, GIN_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageGetOpaque(page)->rightlink == InvalidBlockNumber);
buffer = ReadBuffer(index, metadata->tail);
LockBuffer(buffer, GIN_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
off = (PageIsEmpty(page)) ? FirstOffsetNumber :
OffsetNumberNext(PageGetMaxOffsetNumber(page));
GinMetaPageData *metadata;
BlockNumber blknoToDelete;
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = GinPageGetMeta(metapage);
blknoToDelete = metadata->head;
freespace[data.ndeleted] = blknoToDelete;
buffers[data.ndeleted] = ReadBuffer(index, blknoToDelete);
LockBuffer(buffers[data.ndeleted], GIN_EXCLUSIVE);
- page = BufferGetPage(buffers[data.ndeleted]);
+ page = BufferGetPage(buffers[data.ndeleted], NULL, NULL, BGP_NO_SNAPSHOT_TEST);
data.ndeleted++;
for (i = 0; i < data.ndeleted; i++)
{
- page = BufferGetPage(buffers[i]);
+ page = BufferGetPage(buffers[i], NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinPageGetOpaque(page)->flags = GIN_DELETED;
MarkBufferDirty(buffers[i]);
}
for (i = 0; i < data.ndeleted; i++)
{
- page = BufferGetPage(buffers[i]);
+ page = BufferGetPage(buffers[i], NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
}
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
LockBuffer(metabuffer, GIN_SHARE);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = GinPageGetMeta(metapage);
if (metadata->head == InvalidBlockNumber)
blkno = metadata->head;
buffer = ReadBuffer(index, blkno);
LockBuffer(buffer, GIN_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
LockBuffer(metabuffer, GIN_UNLOCK);
vacuum_delay_point();
buffer = ReadBuffer(index, blkno);
LockBuffer(buffer, GIN_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
ReleaseBuffer(metabuffer);
#include "miscadmin.h"
#include "utils/datum.h"
#include "utils/memutils.h"
+#include "utils/rel.h"
/* GUC parameter */
int GinFuzzySearchLimit = 0;
static bool
moveRightIfItNeeded(GinBtreeData *btree, GinBtreeStack *stack)
{
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (stack->off > PageGetMaxOffsetNumber(page))
{
*/
static void
scanPostingTree(Relation index, GinScanEntry scanEntry,
- BlockNumber rootPostingTree)
+ BlockNumber rootPostingTree, Snapshot snapshot)
{
GinBtreeData btree;
GinBtreeStack *stack;
*/
for (;;)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if ((GinPageGetOpaque(page)->flags & GIN_DELETED) == 0)
{
int n = GinDataLeafPageGetItemsToTbm(page, scanEntry->matchBitmap);
*/
static bool
collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack,
- GinScanEntry scanEntry)
+ GinScanEntry scanEntry, Snapshot snapshot)
{
OffsetNumber attnum;
Form_pg_attribute attr;
if (moveRightIfItNeeded(btree, stack) == false)
return true;
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
/*
LockBuffer(stack->buffer, GIN_UNLOCK);
/* Collect all the TIDs in this entry's posting tree */
- scanPostingTree(btree->index, scanEntry, rootPostingTree);
+ scanPostingTree(btree->index, scanEntry, rootPostingTree, snapshot);
/*
* We lock again the entry page and while it was unlocked insert
* might have occurred, so we need to re-find our position.
*/
LockBuffer(stack->buffer, GIN_SHARE);
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!GinPageIsLeaf(page))
{
/*
if (moveRightIfItNeeded(btree, stack) == false)
elog(ERROR, "lost saved point in index"); /* must not happen !!! */
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
if (gintuple_get_attrnum(btree->ginstate, itup) != attnum)
* Start* functions setup beginning state of searches: finds correct buffer and pins it.
*/
static void
-startScanEntry(GinState *ginstate, GinScanEntry entry)
+startScanEntry(GinState *ginstate, GinScanEntry entry, Snapshot snapshot)
{
GinBtreeData btreeEntry;
GinBtreeStack *stackEntry;
entry->queryKey, entry->queryCategory,
ginstate);
stackEntry = ginFindLeafPage(&btreeEntry, true);
- page = BufferGetPage(stackEntry->buffer);
+ page = BufferGetPage(stackEntry->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
needUnlock = TRUE;
entry->isFinished = TRUE;
* for the entry type.
*/
btreeEntry.findItem(&btreeEntry, stackEntry);
- if (collectMatchBitmap(&btreeEntry, stackEntry, entry) == false)
+ if (!collectMatchBitmap(&btreeEntry, stackEntry, entry, snapshot))
{
/*
* GIN tree was seriously restructured, so we will cleanup all
*/
IncrBufferRefCount(entry->buffer);
- page = BufferGetPage(entry->buffer);
+ page = BufferGetPage(entry->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Load the first page into memory.
uint32 i;
for (i = 0; i < so->totalentries; i++)
- startScanEntry(ginstate, so->entries[i]);
+ startScanEntry(ginstate, so->entries[i], scan->xs_snapshot);
if (GinFuzzySearchLimit > 0)
{
* keep it pinned to prevent interference with vacuum.
*/
static void
-entryLoadMoreItems(GinState *ginstate, GinScanEntry entry, ItemPointerData advancePast)
+entryLoadMoreItems(GinState *ginstate, GinScanEntry entry,
+ ItemPointerData advancePast, Snapshot snapshot)
{
Page page;
int i;
GinItemPointerGetOffsetNumber(&advancePast),
!stepright);
- page = BufferGetPage(entry->buffer);
+ page = BufferGetPage(entry->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
for (;;)
{
entry->offset = InvalidOffsetNumber;
entry->buffer = ginStepRight(entry->buffer,
ginstate->index,
GIN_SHARE);
- page = BufferGetPage(entry->buffer);
+ page = BufferGetPage(entry->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
stepright = true;
*/
static void
entryGetItem(GinState *ginstate, GinScanEntry entry,
- ItemPointerData advancePast)
+ ItemPointerData advancePast, Snapshot snapshot)
{
Assert(!entry->isFinished);
/* If we've processed the current batch, load more items */
while (entry->offset >= entry->nlist)
{
- entryLoadMoreItems(ginstate, entry, advancePast);
+ entryLoadMoreItems(ginstate, entry, advancePast, snapshot);
if (entry->isFinished)
{
*/
static void
keyGetItem(GinState *ginstate, MemoryContext tempCtx, GinScanKey key,
- ItemPointerData advancePast)
+ ItemPointerData advancePast, Snapshot snapshot)
{
ItemPointerData minItem;
ItemPointerData curPageLossy;
*/
if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
{
- entryGetItem(ginstate, entry, advancePast);
+ entryGetItem(ginstate, entry, advancePast, snapshot);
if (entry->isFinished)
continue;
}
if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
{
- entryGetItem(ginstate, entry, advancePast);
+ entryGetItem(ginstate, entry, advancePast, snapshot);
if (entry->isFinished)
continue;
}
GinScanKey key = so->keys + i;
/* Fetch the next item for this key that is > advancePast. */
- keyGetItem(&so->ginstate, so->tempCtx, key, advancePast);
+ keyGetItem(&so->ginstate, so->tempCtx, key, advancePast,
+ scan->xs_snapshot);
if (key->isFinished)
return false;
ItemPointerSetInvalid(&pos->item);
for (;;)
{
- page = BufferGetPage(pos->pendingBuffer);
+ page = BufferGetPage(pos->pendingBuffer, NULL,
+ NULL, BGP_NO_SNAPSHOT_TEST);
maxoff = PageGetMaxOffsetNumber(page);
if (pos->firstOffset > maxoff)
memset(datumExtracted + pos->firstOffset - 1, 0,
sizeof(bool) * (pos->lastOffset - pos->firstOffset));
- page = BufferGetPage(pos->pendingBuffer);
+ page = BufferGetPage(pos->pendingBuffer, NULL,
+ NULL, BGP_NO_SNAPSHOT_TEST);
for (i = 0; i < so->nkeys; i++)
{
int i;
pendingPosition pos;
Buffer metabuffer = ReadBuffer(scan->indexRelation, GIN_METAPAGE_BLKNO);
+ Page page;
BlockNumber blkno;
*ntids = 0;
LockBuffer(metabuffer, GIN_SHARE);
- blkno = GinPageGetMeta(BufferGetPage(metabuffer))->head;
+ page = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
+ blkno = GinPageGetMeta(page)->head;
/*
* fetch head of list before unlocking metapage. head page must be pinned
ginPrepareEntryScan(&btree, attnum, key, category, ginstate);
stack = ginFindLeafPage(&btree, false);
- page = BufferGetPage(stack->buffer);
+ page = BufferGetPage(stack->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (btree.findItem(&btree, stack))
{
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_CREATE_INDEX);
- page = BufferGetPage(RootBuffer);
+ page = BufferGetPage(RootBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
- page = BufferGetPage(MetaBuffer);
+ page = BufferGetPage(MetaBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
*/
if (ConditionalLockBuffer(buffer))
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
return buffer; /* OK to use, if never initialized */
void
GinInitBuffer(Buffer b, uint32 f)
{
- GinInitPage(BufferGetPage(b), f, BufferGetPageSize(b));
+ GinInitPage(BufferGetPage(b, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ f, BufferGetPageSize(b));
}
void
GinInitMetabuffer(Buffer b)
{
GinMetaPageData *metadata;
- Page page = BufferGetPage(b);
+ Page page = BufferGetPage(b, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitPage(page, GIN_META, BufferGetPageSize(b));
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
LockBuffer(metabuffer, GIN_SHARE);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = GinPageGetMeta(metapage);
stats->nPendingPages = metadata->nPendingPages;
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
LockBuffer(metabuffer, GIN_EXCLUSIVE);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metadata = GinPageGetMeta(metapage);
START_CRIT_SECTION();
static void
xlogVacuumPage(Relation index, Buffer buffer)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
XLogRecPtr recptr;
/* This is only used for entry tree leaf pages. */
buffer = ReadBufferExtended(gvs->index, MAIN_FORKNUM, blkno,
RBM_NORMAL, gvs->strategy);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* We should be sure that we don't concurrent with inserts, insert process
START_CRIT_SECTION();
/* Unlink the page by changing left sibling's rightlink */
- page = BufferGetPage(dBuffer);
+ page = BufferGetPage(dBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rightlink = GinPageGetOpaque(page)->rightlink;
- page = BufferGetPage(lBuffer);
+ page = BufferGetPage(lBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinPageGetOpaque(page)->rightlink = rightlink;
/* Delete downlink from parent */
- parentPage = BufferGetPage(pBuffer);
+ parentPage = BufferGetPage(pBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
#ifdef USE_ASSERT_CHECKING
do
{
#endif
GinPageDeletePostingItem(parentPage, myoff);
- page = BufferGetPage(dBuffer);
+ page = BufferGetPage(dBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* we shouldn't change rightlink field to save workability of running
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_PAGE);
PageSetLSN(page, recptr);
PageSetLSN(parentPage, recptr);
- PageSetLSN(BufferGetPage(lBuffer), recptr);
+ PageSetLSN(BufferGetPage(lBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
if (!isParentRoot)
buffer = ReadBufferExtended(gvs->index, MAIN_FORKNUM, blkno,
RBM_NORMAL, gvs->strategy);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageIsData(page));
static Page
ginVacuumEntryPage(GinVacuumState *gvs, Buffer buffer, BlockNumber *roots, uint32 *nroot)
{
- Page origpage = BufferGetPage(buffer),
+ Page origpage = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
tmppage;
OffsetNumber i,
maxoff = PageGetMaxOffsetNumber(origpage);
/* find leaf page */
for (;;)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
IndexTuple itup;
LockBuffer(buffer, GIN_SHARE);
for (;;)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
Page resPage;
uint32 i;
buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
RBM_NORMAL, info->strategy);
LockBuffer(buffer, GIN_SHARE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page) || GinPageIsDeleted(page))
{
if (XLogReadBufferForRedo(record, block_id, &buffer) == BLK_NEEDS_REDO)
{
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinPageGetOpaque(page)->flags &= ~GIN_INCOMPLETE_SPLIT;
PageSetLSN(page, lsn);
MetaBuffer = XLogInitBufferForRedo(record, 0);
Assert(BufferGetBlockNumber(MetaBuffer) == GIN_METAPAGE_BLKNO);
- page = (Page) BufferGetPage(MetaBuffer);
+ page = BufferGetPage(MetaBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitMetabuffer(MetaBuffer);
RootBuffer = XLogInitBufferForRedo(record, 1);
Assert(BufferGetBlockNumber(RootBuffer) == GIN_ROOT_BLKNO);
- page = (Page) BufferGetPage(RootBuffer);
+ page = BufferGetPage(RootBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitBuffer(RootBuffer, GIN_LEAF);
Page page;
buffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitBuffer(buffer, GIN_DATA | GIN_LEAF | GIN_COMPRESSED);
static void
ginRedoInsertEntry(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ginxlogInsertEntry *data = (ginxlogInsertEntry *) rdata;
OffsetNumber offset = data->offset;
IndexTuple itup;
static void
ginRedoInsertData(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (isLeaf)
{
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Size len;
char *payload = XLogRecGetBlockData(record, 0, &len);
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Size len;
ginxlogVacuumDataLeafPage *xlrec;
if (XLogReadBufferForRedo(record, 0, &dbuffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(dbuffer);
+ page = BufferGetPage(dbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageIsData(page));
GinPageGetOpaque(page)->flags = GIN_DELETED;
PageSetLSN(page, lsn);
if (XLogReadBufferForRedo(record, 1, &pbuffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(pbuffer);
+ page = BufferGetPage(pbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageIsData(page));
Assert(!GinPageIsLeaf(page));
GinPageDeletePostingItem(page, data->parentOffset);
if (XLogReadBufferForRedo(record, 2, &lbuffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(lbuffer);
+ page = BufferGetPage(lbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(GinPageIsData(page));
GinPageGetOpaque(page)->rightlink = data->rightLink;
PageSetLSN(page, lsn);
*/
metabuffer = XLogInitBufferForRedo(record, 0);
Assert(BufferGetBlockNumber(metabuffer) == GIN_METAPAGE_BLKNO);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitPage(metapage, GIN_META, BufferGetPageSize(metabuffer));
memcpy(GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));
*/
if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber off;
int i;
Size tupsize;
*/
if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinPageGetOpaque(page)->rightlink = data->newRightlink;
/* We always re-initialize the page. */
buffer = XLogInitBufferForRedo(record, 0);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitBuffer(buffer, GIN_LIST);
GinPageGetOpaque(page)->rightlink = data->rightlink;
metabuffer = XLogInitBufferForRedo(record, 0);
Assert(BufferGetBlockNumber(metabuffer) == GIN_METAPAGE_BLKNO);
- metapage = BufferGetPage(metabuffer);
+ metapage = BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitPage(metapage, GIN_META, BufferGetPageSize(metabuffer));
Page page;
buffer = XLogInitBufferForRedo(record, i + 1);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GinInitBuffer(buffer, GIN_DELETED);
PageSetLSN(page, lsn);
bool markfollowright)
{
BlockNumber blkno = BufferGetBlockNumber(buffer);
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
bool is_leaf = (GistPageIsLeaf(page)) ? true : false;
XLogRecPtr recptr;
int i;
dist->buffer = buffer;
dist->block.blkno = BufferGetBlockNumber(buffer);
- dist->page = PageGetTempPageCopySpecial(BufferGetPage(buffer));
+ dist->page =
+ PageGetTempPageCopySpecial(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/* clean all flags except F_LEAF */
GistPageGetOpaque(dist->page)->flags = (is_leaf) ? F_LEAF : 0;
/* Allocate new page */
ptr->buffer = gistNewBuffer(rel);
GISTInitBuffer(ptr->buffer, (is_leaf) ? F_LEAF : 0);
- ptr->page = BufferGetPage(ptr->buffer);
+ ptr->page = BufferGetPage(ptr->buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ptr->block.blkno = BufferGetBlockNumber(ptr->buffer);
}
int i;
rootpg.buffer = buffer;
- rootpg.page = PageGetTempPageCopySpecial(BufferGetPage(rootpg.buffer));
+ rootpg.page =
+ PageGetTempPageCopySpecial(BufferGetPage(rootpg.buffer,
+ NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
GistPageGetOpaque(rootpg.page)->flags = 0;
/* Prepare a vector of all the downlinks */
* The first page in the chain was a temporary working copy meant to
* replace the old page. Copy it over the old page.
*/
- PageRestoreTempPage(dist->page, BufferGetPage(dist->buffer));
- dist->page = BufferGetPage(dist->buffer);
+ PageRestoreTempPage(dist->page, BufferGetPage(dist->buffer,
+ NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
+ dist->page = BufferGetPage(dist->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/* Write the WAL record */
if (RelationNeedsWAL(rel))
*/
if (BufferIsValid(leftchildbuf))
{
- Page leftpg = BufferGetPage(leftchildbuf);
+ Page leftpg = BufferGetPage(leftchildbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
GistPageSetNSN(leftpg, recptr);
GistClearFollowRight(leftpg);
gistcheckpage(state.r, stack->buffer);
}
- stack->page = (Page) BufferGetPage(stack->buffer);
+ stack->page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
stack->lsn = PageGetLSN(stack->page);
Assert(!RelationNeedsWAL(state.r) || !XLogRecPtrIsInvalid(stack->lsn));
LockBuffer(stack->buffer, GIST_UNLOCK);
LockBuffer(stack->buffer, GIST_EXCLUSIVE);
xlocked = true;
- stack->page = (Page) BufferGetPage(stack->buffer);
+ stack->page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (PageGetLSN(stack->page) != stack->lsn)
{
LockBuffer(stack->buffer, GIST_UNLOCK);
LockBuffer(stack->buffer, GIST_EXCLUSIVE);
xlocked = true;
- stack->page = (Page) BufferGetPage(stack->buffer);
+ stack->page = BufferGetPage(stack->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
stack->lsn = PageGetLSN(stack->page);
if (stack->blkno == GIST_ROOT_BLKNO)
buffer = ReadBuffer(r, top->blkno);
LockBuffer(buffer, GIST_SHARE);
gistcheckpage(r, buffer);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GistPageIsLeaf(page))
{
GISTInsertStack *parent = child->parent;
gistcheckpage(r, parent->buffer);
- parent->page = (Page) BufferGetPage(parent->buffer);
+ parent->page = BufferGetPage(parent->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/* here we don't need to distinguish between split and page update */
if (child->downlinkoffnum == InvalidOffsetNumber ||
parent->buffer = ReadBuffer(r, parent->blkno);
LockBuffer(parent->buffer, GIST_EXCLUSIVE);
gistcheckpage(r, parent->buffer);
- parent->page = (Page) BufferGetPage(parent->buffer);
+ parent->page = BufferGetPage(parent->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
}
/*
while (ptr)
{
ptr->buffer = ReadBuffer(r, ptr->blkno);
- ptr->page = (Page) BufferGetPage(ptr->buffer);
+ ptr->page = BufferGetPage(ptr->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
ptr = ptr->parent;
}
gistformdownlink(Relation rel, Buffer buf, GISTSTATE *giststate,
GISTInsertStack *stack)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber maxoff;
OffsetNumber offset;
IndexTuple downlink = NULL;
GISTPageSplitInfo *si = palloc(sizeof(GISTPageSplitInfo));
IndexTuple downlink;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* Form the new downlink tuples to insert to parent */
downlink = gistformdownlink(state->r, buf, giststate, stack);
/* initialize the root page */
buffer = gistNewBuffer(index);
Assert(BufferGetBlockNumber(buffer) == GIST_ROOT_BLKNO);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
START_CRIT_SECTION();
buffer = ReadBuffer(indexrel, blkno);
LockBuffer(buffer, GIST_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
childoffnum = gistchoose(indexrel, page, itup, giststate);
iid = PageGetItemId(page, childoffnum);
idxtuple = (IndexTuple) PageGetItem(page, iid);
*/
if (is_split && BufferGetBlockNumber(buffer) == GIST_ROOT_BLKNO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
OffsetNumber off;
OffsetNumber maxoff;
}
buffer = ReadBuffer(buildstate->indexrel, parent);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
LockBuffer(buffer, GIST_EXCLUSIVE);
gistcheckpage(buildstate->indexrel, buffer);
maxoff = PageGetMaxOffsetNumber(page);
* pro forma.
*/
LockBuffer(buffer, GIST_SHARE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GistPageIsLeaf(page))
{
OffsetNumber maxoff;
OffsetNumber off;
BlockNumber parentblkno = BufferGetBlockNumber(parentbuf);
- Page page = BufferGetPage(parentbuf);
+ Page page = BufferGetPage(parentbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
Assert(!GistPageIsLeaf(page));
LockBuffer(buffer, GIST_SHARE);
gistcheckpage(scan->indexRelation, buffer);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* If page LSN differs it means that the page was modified since the last read.
buffer = ReadBuffer(scan->indexRelation, pageItem->blkno);
LockBuffer(buffer, GIST_SHARE);
gistcheckpage(scan->indexRelation, buffer);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = GistPageGetOpaque(page);
/*
Size pageSize;
pageSize = BufferGetPageSize(b);
- page = BufferGetPage(b);
+ page = BufferGetPage(b, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, pageSize, sizeof(GISTPageOpaqueData));
opaque = GistPageGetOpaque(page);
void
gistcheckpage(Relation rel, Buffer buf)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* ReadBuffer verifies that every newly-read page passes
*/
if (ConditionalLockBuffer(buffer))
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
return buffer; /* OK to use, if never initialized */
buffer = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL,
info->strategy);
LockBuffer(buffer, GIST_SHARE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page) || GistPageIsDeleted(page))
{
RBM_NORMAL, info->strategy);
LockBuffer(buffer, GIST_SHARE);
gistcheckpage(rel, buffer);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (GistPageIsLeaf(page))
{
LockBuffer(buffer, GIST_UNLOCK);
LockBuffer(buffer, GIST_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (stack->blkno == GIST_ROOT_BLKNO && !GistPageIsLeaf(page))
{
/* only the root can become non-leaf during relock */
action = XLogReadBufferForRedo(record, block_id, &buffer);
if (action == BLK_NEEDS_REDO || action == BLK_RESTORED)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GistPageSetNSN(page, lsn);
GistClearFollowRight(page);
data = begin = XLogRecGetBlockData(record, 0, &datalen);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* Delete old tuples */
if (xldata->ntodelete > 0)
}
buffer = XLogInitBufferForRedo(record, i + 1);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
data = XLogRecGetBlockData(record, i + 1, &datalen);
tuples = decodePageSplitRecord(data, datalen, &num);
buffer = XLogInitBufferForRedo(record, 0);
Assert(BufferGetBlockNumber(buffer) == GIST_ROOT_BLKNO);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
GISTInitBuffer(buffer, F_LEAF);
buf = so->hashso_curbuf;
Assert(BufferIsValid(buf));
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
maxoffnum = PageGetMaxOffsetNumber(page);
for (offnum = ItemPointerGetOffsetNumber(current);
offnum <= maxoffnum;
while (res)
{
offnum = ItemPointerGetOffsetNumber(current);
- page = BufferGetPage(so->hashso_curbuf);
+ page = BufferGetPage(so->hashso_curbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (!ItemIdIsDead(PageGetItemId(page, offnum)))
break;
res = _hash_next(scan, dir);
OffsetNumber offnum;
offnum = ItemPointerGetOffsetNumber(&(so->hashso_curpos));
- page = BufferGetPage(so->hashso_curbuf);
+ page = BufferGetPage(so->hashso_curbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
add_tuple = !ItemIdIsDead(PageGetItemId(page, offnum));
}
else
* each bucket.
*/
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
orig_maxbucket = metap->hashm_maxbucket;
orig_ntuples = metap->hashm_ntuples;
memcpy(&local_metapage, metap, sizeof(local_metapage));
buf = _hash_getbuf_with_strategy(rel, blkno, HASH_WRITE,
LH_BUCKET_PAGE | LH_OVERFLOW_PAGE,
info->strategy);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (HashPageOpaque) PageGetSpecialPointer(page);
Assert(opaque->hasho_bucket == cur_bucket);
/* Write-lock metapage and check for split since we started */
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_WRITE, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
if (cur_maxbucket != metap->hashm_maxbucket)
{
/* Read the metapage */
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/*
* Check whether the item can fit on a hash page at all. (Eventually, we
/* Fetch the primary bucket page for the bucket */
buf = _hash_getbuf(rel, blkno, HASH_WRITE, LH_BUCKET_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageopaque = (HashPageOpaque) PageGetSpecialPointer(page);
Assert(pageopaque->hasho_bucket == bucket);
*/
_hash_relbuf(rel, buf);
buf = _hash_getbuf(rel, nextblkno, HASH_WRITE, LH_OVERFLOW_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
else
{
/* chain to a new overflow page */
buf = _hash_addovflpage(rel, metabuf, buf);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* should fit now, given test above */
Assert(PageGetFreeSpace(page) >= itemsz);
uint32 hashkey;
_hash_checkpage(rel, buf, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* Find where to insert the tuple (preserving page's hashkey ordering) */
hashkey = _hash_get_indextuple_hashkey(itup);
{
BlockNumber nextblkno;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageopaque = (HashPageOpaque) PageGetSpecialPointer(page);
nextblkno = pageopaque->hasho_nextblkno;
}
/* now that we have correct backlink, initialize new overflow page */
- ovflpage = BufferGetPage(ovflbuf);
+ ovflpage = BufferGetPage(ovflbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ovflopaque = (HashPageOpaque) PageGetSpecialPointer(ovflpage);
ovflopaque->hasho_prevblkno = BufferGetBlockNumber(buf);
ovflopaque->hasho_nextblkno = InvalidBlockNumber;
_hash_chgbufaccess(rel, metabuf, HASH_NOLOCK, HASH_WRITE);
_hash_checkpage(rel, metabuf, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/* start search at hashm_firstfree */
orig_firstfree = metap->hashm_firstfree;
_hash_chgbufaccess(rel, metabuf, HASH_READ, HASH_NOLOCK);
mapbuf = _hash_getbuf(rel, mapblkno, HASH_WRITE, LH_BITMAP_PAGE);
- mappage = BufferGetPage(mapbuf);
+ mappage = BufferGetPage(mapbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
freep = HashPageGetBitmap(mappage);
for (; bit <= last_inpage; j++, bit += BITS_PER_MAP)
/* Get information from the doomed page */
_hash_checkpage(rel, ovflbuf, LH_OVERFLOW_PAGE);
ovflblkno = BufferGetBlockNumber(ovflbuf);
- ovflpage = BufferGetPage(ovflbuf);
+ ovflpage = BufferGetPage(ovflbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ovflopaque = (HashPageOpaque) PageGetSpecialPointer(ovflpage);
nextblkno = ovflopaque->hasho_nextblkno;
prevblkno = ovflopaque->hasho_prevblkno;
HASH_WRITE,
LH_BUCKET_PAGE | LH_OVERFLOW_PAGE,
bstrategy);
- Page prevpage = BufferGetPage(prevbuf);
+ Page prevpage = BufferGetPage(prevbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
HashPageOpaque prevopaque = (HashPageOpaque) PageGetSpecialPointer(prevpage);
Assert(prevopaque->hasho_bucket == bucket);
HASH_WRITE,
LH_OVERFLOW_PAGE,
bstrategy);
- Page nextpage = BufferGetPage(nextbuf);
+ Page nextpage = BufferGetPage(nextbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
HashPageOpaque nextopaque = (HashPageOpaque) PageGetSpecialPointer(nextpage);
Assert(nextopaque->hasho_bucket == bucket);
/* Read the metapage so we can determine which bitmap page to use */
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/* Identify which bit to set */
ovflbitno = blkno_to_bitno(metap, ovflblkno);
/* Clear the bitmap bit to indicate that this overflow page is free */
mapbuf = _hash_getbuf(rel, blkno, HASH_WRITE, LH_BITMAP_PAGE);
- mappage = BufferGetPage(mapbuf);
+ mappage = BufferGetPage(mapbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
freep = HashPageGetBitmap(mappage);
Assert(ISSET(freep, bitmapbit));
CLRBIT(freep, bitmapbit);
* that it's not worth worrying about.
*/
buf = _hash_getnewbuf(rel, blkno, forkNum);
- pg = BufferGetPage(buf);
+ pg = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* initialize the page's special space */
op = (HashPageOpaque) PageGetSpecialPointer(pg);
HASH_WRITE,
LH_BUCKET_PAGE,
bstrategy);
- wpage = BufferGetPage(wbuf);
+ wpage = BufferGetPage(wbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
wopaque = (HashPageOpaque) PageGetSpecialPointer(wpage);
/*
HASH_WRITE,
LH_OVERFLOW_PAGE,
bstrategy);
- rpage = BufferGetPage(rbuf);
+ rpage = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ropaque = (HashPageOpaque) PageGetSpecialPointer(rpage);
Assert(ropaque->hasho_bucket == bucket);
} while (BlockNumberIsValid(ropaque->hasho_nextblkno));
HASH_WRITE,
LH_OVERFLOW_PAGE,
bstrategy);
- wpage = BufferGetPage(wbuf);
+ wpage = BufferGetPage(wbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
wopaque = (HashPageOpaque) PageGetSpecialPointer(wpage);
Assert(wopaque->hasho_bucket == bucket);
wbuf_dirty = false;
HASH_WRITE,
LH_OVERFLOW_PAGE,
bstrategy);
- rpage = BufferGetPage(rbuf);
+ rpage = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
ropaque = (HashPageOpaque) PageGetSpecialPointer(rpage);
Assert(ropaque->hasho_bucket == bucket);
}
/* ref count and lock type are correct */
/* initialize the page */
- _hash_pageinit(BufferGetPage(buf), BufferGetPageSize(buf));
+ _hash_pageinit(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BufferGetPageSize(buf));
return buf;
}
/* ref count and lock type are correct */
/* initialize the page */
- _hash_pageinit(BufferGetPage(buf), BufferGetPageSize(buf));
+ _hash_pageinit(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BufferGetPageSize(buf));
return buf;
}
* the physical index length.
*/
metabuf = _hash_getnewbuf(rel, HASH_METAPAGE, forkNum);
- pg = BufferGetPage(metabuf);
+ pg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageopaque = (HashPageOpaque) PageGetSpecialPointer(pg);
pageopaque->hasho_prevblkno = InvalidBlockNumber;
CHECK_FOR_INTERRUPTS();
buf = _hash_getnewbuf(rel, BUCKET_TO_BLKNO(metap, i), forkNum);
- pg = BufferGetPage(buf);
+ pg = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageopaque = (HashPageOpaque) PageGetSpecialPointer(pg);
pageopaque->hasho_prevblkno = InvalidBlockNumber;
pageopaque->hasho_nextblkno = InvalidBlockNumber;
_hash_chgbufaccess(rel, metabuf, HASH_NOLOCK, HASH_WRITE);
_hash_checkpage(rel, metabuf, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/*
* Check to see if split is still needed; someone else might have already
* either bucket.
*/
obuf = _hash_getbuf(rel, start_oblkno, HASH_WRITE, LH_BUCKET_PAGE);
- opage = BufferGetPage(obuf);
+ opage = BufferGetPage(obuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
oopaque = (HashPageOpaque) PageGetSpecialPointer(opage);
- npage = BufferGetPage(nbuf);
+ npage = BufferGetPage(nbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* initialize the new bucket's primary page */
nopaque = (HashPageOpaque) PageGetSpecialPointer(npage);
_hash_chgbufaccess(rel, nbuf, HASH_WRITE, HASH_NOLOCK);
/* chain to a new overflow page */
nbuf = _hash_addovflpage(rel, metabuf, nbuf);
- npage = BufferGetPage(nbuf);
+ npage = BufferGetPage(nbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* we don't need nopaque within the loop */
}
/* Else, advance to next old page */
obuf = _hash_getbuf(rel, oblkno, HASH_WRITE, LH_OVERFLOW_PAGE);
- opage = BufferGetPage(obuf);
+ opage = BufferGetPage(obuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
oopaque = (HashPageOpaque) PageGetSpecialPointer(opage);
}
current = &(so->hashso_curpos);
offnum = ItemPointerGetOffsetNumber(current);
_hash_checkpage(rel, buf, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
so->hashso_heappos = itup->t_tid;
if (BlockNumberIsValid(blkno))
{
*bufp = _hash_getbuf(rel, blkno, HASH_READ, LH_OVERFLOW_PAGE);
- *pagep = BufferGetPage(*bufp);
+ *pagep = BufferGetPage(*bufp, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
*opaquep = (HashPageOpaque) PageGetSpecialPointer(*pagep);
}
}
{
*bufp = _hash_getbuf(rel, blkno, HASH_READ,
LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- *pagep = BufferGetPage(*bufp);
+ *pagep = BufferGetPage(*bufp, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
*opaquep = (HashPageOpaque) PageGetSpecialPointer(*pagep);
}
}
/* Read the metapage */
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ page = BufferGetPage(metabuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
+ metap = HashPageGetMeta(page);
/*
* Loop until we get a lock on the correct target bucket.
/* Fetch the primary bucket page for the bucket */
buf = _hash_getbuf(rel, blkno, HASH_READ, LH_BUCKET_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (HashPageOpaque) PageGetSpecialPointer(page);
Assert(opaque->hasho_bucket == bucket);
/* if we're here, _hash_step found a valid tuple */
offnum = ItemPointerGetOffsetNumber(current);
_hash_checkpage(rel, buf, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
so->hashso_heappos = itup->t_tid;
buf = *bufP;
_hash_checkpage(rel, buf, LH_BUCKET_PAGE | LH_OVERFLOW_PAGE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (HashPageOpaque) PageGetSpecialPointer(page);
/*
void
_hash_checkpage(Relation rel, Buffer buf, int flags)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* ReadBuffer verifies that every newly-read page passes
*/
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- dp = (Page) BufferGetPage(buffer);
+ dp = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = PageGetMaxOffsetNumber(dp);
ntup = 0;
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = PageGetMaxOffsetNumber(dp);
/* page and lineoff now reference the physically next tid */
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = PageGetMaxOffsetNumber(dp);
if (!scan->rs_inited)
heapgetpage(scan, page);
/* Since the tuple was previously fetched, needn't lock page here */
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff);
Assert(ItemIdIsNormal(lpp));
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = PageGetMaxOffsetNumber((Page) dp);
linesleft = lines;
if (backward)
lineindex = scan->rs_cindex + 1;
}
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = scan->rs_ntuples;
/* page and lineindex now reference the next visible tid */
page = scan->rs_cblock; /* current page */
}
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = scan->rs_ntuples;
if (!scan->rs_inited)
heapgetpage(scan, page);
/* Since the tuple was previously fetched, needn't lock page here */
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff);
Assert(ItemIdIsNormal(lpp));
heapgetpage(scan, page);
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lines = scan->rs_ntuples;
linesleft = lines;
if (backward)
* Need share lock on buffer to examine tuple commit status.
*/
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* We'd better check for out-of-range offnum in case of VACUUM since the
Snapshot snapshot, HeapTuple heapTuple,
bool *all_dead, bool first_call)
{
- Page dp = (Page) BufferGetPage(buffer);
+ Page dp = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
TransactionId prev_xmax = InvalidTransactionId;
OffsetNumber offnum;
bool at_chain_start;
*/
buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&ctid));
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Check for bogus item number. This is not treated as an error
RelationPutHeapTuple(relation, buffer, heaptup,
(options & HEAP_INSERT_SPECULATIVE) != 0);
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
{
all_visible_cleared = true;
- PageClearAllVisible(BufferGetPage(buffer));
+ PageClearAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
visibilitymap_clear(relation,
ItemPointerGetBlockNumber(&(heaptup->t_self)),
vmbuffer);
xl_heap_insert xlrec;
xl_heap_header xlhdr;
XLogRecPtr recptr;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
uint8 info = XLOG_HEAP_INSERT;
int bufflags = 0;
buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
InvalidBuffer, options, bistate,
&vmbuffer, NULL);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* NO EREPORT(ERROR) from here till changes are logged */
START_CRIT_SECTION();
block = ItemPointerGetBlockNumber(tid);
buffer = ReadBuffer(relation, block);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Before locking the buffer, pin the visibility map page if it appears to
block = ItemPointerGetBlockNumber(otid);
buffer = ReadBuffer(relation, block);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Before locking the buffer, pin the visibility map page if it appears to
oldtup.t_data->t_ctid = heaptup->t_self;
/* clear PD_ALL_VISIBLE flags */
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
{
all_visible_cleared = true;
- PageClearAllVisible(BufferGetPage(buffer));
+ PageClearAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
visibilitymap_clear(relation, BufferGetBlockNumber(buffer),
vmbuffer);
}
- if (newbuf != buffer && PageIsAllVisible(BufferGetPage(newbuf)))
+ if (newbuf != buffer &&
+ PageIsAllVisible(BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
{
all_visible_cleared_new = true;
- PageClearAllVisible(BufferGetPage(newbuf));
+ PageClearAllVisible(BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
visibilitymap_clear(relation, BufferGetBlockNumber(newbuf),
vmbuffer_new);
}
all_visible_cleared_new);
if (newbuf != buffer)
{
- PageSetLSN(BufferGetPage(newbuf), recptr);
+ PageSetLSN(BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ recptr);
}
- PageSetLSN(BufferGetPage(buffer), recptr);
+ PageSetLSN(BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ recptr);
}
END_CRIT_SECTION();
*buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(*buffer);
+ page = BufferGetPage(*buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
Assert(ItemIdIsNormal(lp));
{
xl_heap_lock_updated xlrec;
XLogRecPtr recptr;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
XLogBeginInsert();
XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&(tuple->t_self)));
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = ItemPointerGetOffsetNumber(&(tuple->t_self));
if (PageGetMaxOffsetNumber(page) >= offnum)
block = ItemPointerGetBlockNumber(tid);
buffer = ReadBuffer(relation, block);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&(tuple->t_self)));
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = ItemPointerGetOffsetNumber(&(tuple->t_self));
if (PageGetMaxOffsetNumber(page) >= offnum)
uint16 prefixlen = 0,
suffixlen = 0;
XLogRecPtr recptr;
- Page page = BufferGetPage(newbuf);
+ Page page = BufferGetPage(newbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
bool need_tuple_data = RelationIsLogicallyLogged(reln);
bool init;
int bufflags;
&buffer);
if (action == BLK_NEEDS_REDO)
{
- Page page = (Page) BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
OffsetNumber *end;
OffsetNumber *redirected;
OffsetNumber *nowdead;
* XLOG record's LSN, we mustn't mark the page all-visible, because
* the subsequent update won't be replayed to clear the flag.
*/
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetAllVisible(page);
if (XLogReadBufferForRedoExtended(record, 0, RBM_ZERO_ON_ERROR, false,
&vmbuffer) == BLK_NEEDS_REDO)
{
- Page vmpage = BufferGetPage(vmbuffer);
+ Page vmpage = BufferGetPage(vmbuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
Relation reln;
/* initialize the page if it was read as zeros */
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
xl_heap_freeze_tuple *tuples;
tuples = (xl_heap_freeze_tuple *) XLogRecGetBlockData(record, 0, NULL);
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageGetMaxOffsetNumber(page) >= xlrec->offnum)
lp = PageGetItemId(page, xlrec->offnum);
if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
{
buffer = XLogInitBufferForRedo(record, 0);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, BufferGetPageSize(buffer), 0);
action = BLK_NEEDS_REDO;
}
Size datalen;
char *data;
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageGetMaxOffsetNumber(page) + 1 < xlrec->offnum)
elog(PANIC, "invalid max offset number");
if (isinit)
{
buffer = XLogInitBufferForRedo(record, 0);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, BufferGetPageSize(buffer), 0);
action = BLK_NEEDS_REDO;
}
tupdata = XLogRecGetBlockData(record, 0, &len);
endptr = tupdata + len;
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
for (i = 0; i < xlrec->ntuples; i++)
{
&obuffer);
if (oldaction == BLK_NEEDS_REDO)
{
- page = BufferGetPage(obuffer);
+ page = BufferGetPage(obuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->old_offnum;
if (PageGetMaxOffsetNumber(page) >= offnum)
lp = PageGetItemId(page, offnum);
else if (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE)
{
nbuffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(nbuffer);
+ page = BufferGetPage(nbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, BufferGetPageSize(nbuffer), 0);
newaction = BLK_NEEDS_REDO;
}
recdata = XLogRecGetBlockData(record, 0, &datalen);
recdata_end = recdata + datalen;
- page = BufferGetPage(nbuffer);
+ page = BufferGetPage(nbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->new_offnum;
if (PageGetMaxOffsetNumber(page) + 1 < offnum)
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) >= offnum)
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) >= offnum)
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) >= offnum)
{
char *newtup = XLogRecGetBlockData(record, 0, &newlen);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = xlrec->offnum;
if (PageGetMaxOffsetNumber(page) >= offnum)
Assert(!token || HeapTupleHeaderIsSpeculative(tuple->t_data));
/* Add the tuple to the page */
- pageHeader = BufferGetPage(buffer);
+ pageHeader = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
offnum = PageAddItem(pageHeader, (Item) tuple->t_data,
tuple->t_len, InvalidOffsetNumber, false, true);
while (1)
{
/* Figure out which pins we need but don't have. */
- need_to_pin_buffer1 = PageIsAllVisible(BufferGetPage(buffer1))
+ need_to_pin_buffer1 =
+ PageIsAllVisible(BufferGetPage(buffer1, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST))
&& !visibilitymap_pin_ok(block1, *vmbuffer1);
need_to_pin_buffer2 = buffer2 != InvalidBuffer
- && PageIsAllVisible(BufferGetPage(buffer2))
+ && PageIsAllVisible(BufferGetPage(buffer2, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST))
&& !visibilitymap_pin_ok(block2, *vmbuffer2);
if (!need_to_pin_buffer1 && !need_to_pin_buffer2)
return;
/* Extend by one page. */
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, BufferGetPageSize(buffer), 0);
MarkBufferDirty(buffer);
blockNum = BufferGetBlockNumber(buffer);
{
/* easy case */
buffer = ReadBufferBI(relation, targetBlock, bistate);
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
visibilitymap_pin(relation, targetBlock, vmbuffer);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
}
{
/* also easy case */
buffer = otherBuffer;
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
visibilitymap_pin(relation, targetBlock, vmbuffer);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
}
{
/* lock other buffer first */
buffer = ReadBuffer(relation, targetBlock);
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
visibilitymap_pin(relation, targetBlock, vmbuffer);
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
{
/* lock target buffer first */
buffer = ReadBuffer(relation, targetBlock);
- if (PageIsAllVisible(BufferGetPage(buffer)))
+ if (PageIsAllVisible(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
visibilitymap_pin(relation, targetBlock, vmbuffer);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
LockBuffer(otherBuffer, BUFFER_LOCK_EXCLUSIVE);
* Now we can check to see if there's enough free space here. If so,
* we're done.
*/
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageFreeSpace = PageGetHeapFreeSpace(page);
if (len + saveFreeSpace <= pageFreeSpace)
{
* is empty (this should never happen, but if it does we don't want to
* risk wiping out valid data).
*/
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!PageIsNew(page))
elog(ERROR, "page %u of relation \"%s\" should be empty but is not",
void
heap_page_prune_opt(Relation relation, Buffer buffer)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Size minfree;
TransactionId OldestXmin;
bool report_stats, TransactionId *latestRemovedXid)
{
int ndeleted = 0;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber offnum,
maxoff;
PruneState prstate;
prstate.nowunused, prstate.nunused,
prstate.latestRemovedXid);
- PageSetLSN(BufferGetPage(buffer), recptr);
+ PageSetLSN(BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
}
else
PruneState *prstate)
{
int ndeleted = 0;
- Page dp = (Page) BufferGetPage(buffer);
+ Page dp = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
TransactionId priorXmax = InvalidTransactionId;
ItemId rootlp;
HeapTupleHeader htup;
OffsetNumber *nowdead, int ndead,
OffsetNumber *nowunused, int nunused)
{
- Page page = (Page) BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
OffsetNumber *offnum;
int i;
elog(ERROR, "wrong buffer passed to visibilitymap_clear");
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- map = PageGetContents(BufferGetPage(buf));
+ map = PageGetContents(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
if (map[mapByte] & mask)
{
if (!BufferIsValid(vmBuf) || BufferGetBlockNumber(vmBuf) != mapBlock)
elog(ERROR, "wrong VM buffer passed to visibilitymap_set");
- page = BufferGetPage(vmBuf);
+ page = BufferGetPage(vmBuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
map = (uint8 *)PageGetContents(page);
LockBuffer(vmBuf, BUFFER_LOCK_EXCLUSIVE);
*/
if (XLogHintBitIsNeeded())
{
- Page heapPage = BufferGetPage(heapBuf);
+ Page heapPage = BufferGetPage(heapBuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/* caller is expected to set PD_ALL_VISIBLE first */
Assert(PageIsAllVisible(heapPage));
return false;
}
- map = PageGetContents(BufferGetPage(*buf));
+ map = PageGetContents(BufferGetPage(*buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/*
* A single byte read is atomic. There could be memory-ordering effects
* immediately stale anyway if anyone is concurrently setting or
* clearing bits, and we only really need an approximate value.
*/
- map = (unsigned char *) PageGetContents(BufferGetPage(mapBuffer));
+ map = (unsigned char *) PageGetContents(BufferGetPage
+ (mapBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
for (i = 0; i < MAPSIZE; i++)
{
return;
}
- page = BufferGetPage(mapBuffer);
+ page = BufferGetPage(mapBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
map = PageGetContents(page);
LockBuffer(mapBuffer, BUFFER_LOCK_EXCLUSIVE);
*/
buf = ReadBufferExtended(rel, VISIBILITYMAP_FORKNUM, blkno,
RBM_ZERO_ON_ERROR, NULL);
- if (PageIsNew(BufferGetPage(buf)))
- PageInit(BufferGetPage(buf), BLCKSZ, 0);
+ if (PageIsNew(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST)))
+ PageInit(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BLCKSZ, 0);
return buf;
}
InitDirtySnapshot(SnapshotDirty);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
maxoff = PageGetMaxOffsetNumber(page);
{
nblkno = opaque->btpo_next;
nbuf = _bt_relandgetbuf(rel, nbuf, nblkno, BT_READ);
- page = BufferGetPage(nbuf);
+ page = BufferGetPage(nbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (!P_IGNORE(opaque))
break;
Relation heapRel)
{
Buffer buf = *bufptr;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Size itemsz;
BTPageOpaque lpageop;
bool movedright,
for (;;)
{
rbuf = _bt_relandgetbuf(rel, rbuf, rblkno, BT_WRITE);
- page = BufferGetPage(rbuf);
+ page = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lpageop = (BTPageOpaque) PageGetSpecialPointer(page);
/*
OffsetNumber firstright = InvalidOffsetNumber;
Size itemsz;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lpageop = (BTPageOpaque) PageGetSpecialPointer(page);
/* child buffer must be given iff inserting on an internal page */
Assert(!P_ISLEAF(lpageop));
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metad = BTPageGetMeta(metapg);
if (metad->btm_fastlevel >= lpageop->btpo.level)
/* clear INCOMPLETE_SPLIT flag on child if inserting a downlink */
if (BufferIsValid(cbuf))
{
- Page cpage = BufferGetPage(cbuf);
+ Page cpage = BufferGetPage(cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTPageOpaque cpageop = (BTPageOpaque) PageGetSpecialPointer(cpage);
Assert(P_INCOMPLETE_SPLIT(cpageop));
}
if (BufferIsValid(cbuf))
{
- PageSetLSN(BufferGetPage(cbuf), recptr);
+ PageSetLSN(BufferGetPage(cbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
PageSetLSN(page, recptr);
* possibly-confusing junk behind, we are careful to rewrite rightpage as
* zeroes before throwing any error.
*/
- origpage = BufferGetPage(buf);
+ origpage = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
leftpage = PageGetTempPage(origpage);
- rightpage = BufferGetPage(rbuf);
+ rightpage = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
origpagenumber = BufferGetBlockNumber(buf);
rightpagenumber = BufferGetBlockNumber(rbuf);
if (!P_RIGHTMOST(oopaque))
{
sbuf = _bt_getbuf(rel, oopaque->btpo_next, BT_WRITE);
- spage = BufferGetPage(sbuf);
+ spage = BufferGetPage(sbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
sopaque = (BTPageOpaque) PageGetSpecialPointer(spage);
if (sopaque->btpo_prev != origpagenumber)
{
*/
if (!isleaf)
{
- Page cpage = BufferGetPage(cbuf);
+ Page cpage = BufferGetPage(cbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
BTPageOpaque cpageop = (BTPageOpaque) PageGetSpecialPointer(cpage);
cpageop->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
}
if (!isleaf)
{
- PageSetLSN(BufferGetPage(cbuf), recptr);
+ PageSetLSN(BufferGetPage(cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ recptr);
}
}
{
BlockNumber bknum = BufferGetBlockNumber(buf);
BlockNumber rbknum = BufferGetBlockNumber(rbuf);
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
IndexTuple new_item;
BTStackData fakestack;
IndexTuple ritem;
void
_bt_finish_split(Relation rel, Buffer lbuf, BTStack stack)
{
- Page lpage = BufferGetPage(lbuf);
+ Page lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTPageOpaque lpageop = (BTPageOpaque) PageGetSpecialPointer(lpage);
Buffer rbuf;
Page rpage;
/* Lock right sibling, the one missing the downlink */
rbuf = _bt_getbuf(rel, lpageop->btpo_next, BT_WRITE);
- rpage = BufferGetPage(rbuf);
+ rpage = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rpageop = (BTPageOpaque) PageGetSpecialPointer(rpage);
/* Could this be a root split? */
/* acquire lock on the metapage */
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metad = BTPageGetMeta(metapg);
was_root = (metad->btm_root == BufferGetBlockNumber(lbuf));
BTPageOpaque opaque;
buf = _bt_getbuf(rel, blkno, access);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (access == BT_WRITE && P_INCOMPLETE_SPLIT(opaque))
lbkno = BufferGetBlockNumber(lbuf);
rbkno = BufferGetBlockNumber(rbuf);
- lpage = BufferGetPage(lbuf);
+ lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
/* get a new root page */
rootbuf = _bt_getbuf(rel, P_NEW, BT_WRITE);
- rootpage = BufferGetPage(rootbuf);
+ rootpage = BufferGetPage(rootbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rootblknum = BufferGetBlockNumber(rootbuf);
/* acquire lock on the metapage */
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metad = BTPageGetMeta(metapg);
/*
OffsetNumber offnum,
minoff,
maxoff;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTPageOpaque opaque = (BTPageOpaque) PageGetSpecialPointer(page);
/*
rootlevel = metad->btm_fastlevel;
rootbuf = _bt_getbuf(rel, rootblkno, BT_READ);
- rootpage = BufferGetPage(rootbuf);
+ rootpage = BufferGetPage(rootbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rootopaque = (BTPageOpaque) PageGetSpecialPointer(rootpage);
/*
}
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metaopaque = (BTPageOpaque) PageGetSpecialPointer(metapg);
metad = BTPageGetMeta(metapg);
*/
rootbuf = _bt_getbuf(rel, P_NEW, BT_WRITE);
rootblkno = BufferGetBlockNumber(rootbuf);
- rootpage = BufferGetPage(rootbuf);
+ rootpage = BufferGetPage(rootbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rootopaque = (BTPageOpaque) PageGetSpecialPointer(rootpage);
rootopaque->btpo_prev = rootopaque->btpo_next = P_NONE;
rootopaque->btpo_flags = (BTP_LEAF | BTP_ROOT);
for (;;)
{
rootbuf = _bt_relandgetbuf(rel, rootbuf, rootblkno, BT_READ);
- rootpage = BufferGetPage(rootbuf);
+ rootpage = BufferGetPage(rootbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rootopaque = (BTPageOpaque) PageGetSpecialPointer(rootpage);
if (!P_IGNORE(rootopaque))
rel->rd_amcache = NULL;
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metaopaque = (BTPageOpaque) PageGetSpecialPointer(metapg);
metad = BTPageGetMeta(metapg);
for (;;)
{
rootbuf = _bt_relandgetbuf(rel, rootbuf, rootblkno, BT_READ);
- rootpage = BufferGetPage(rootbuf);
+ rootpage = BufferGetPage(rootbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
rootopaque = (BTPageOpaque) PageGetSpecialPointer(rootpage);
if (!P_IGNORE(rootopaque))
BTPageOpaque metaopaque;
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metaopaque = (BTPageOpaque) PageGetSpecialPointer(metapg);
metad = BTPageGetMeta(metapg);
void
_bt_checkpage(Relation rel, Buffer buf)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* ReadBuffer verifies that every newly-read page passes
buf = ReadBuffer(rel, blkno);
if (ConditionalLockBuffer(buf))
{
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (_bt_page_recyclable(page))
{
/*
UnlockRelationForExtension(rel, ExclusiveLock);
/* Initialize the new page before returning it */
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
Assert(PageIsNew(page));
_bt_pageinit(page, BufferGetPageSize(buf));
}
OffsetNumber *itemnos, int nitems,
BlockNumber lastBlockVacuumed)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTPageOpaque opaque;
/* No ereport(ERROR) until changes are logged */
OffsetNumber *itemnos, int nitems,
Relation heapRel)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BTPageOpaque opaque;
/* Shouldn't be called unless there's something to do */
bool result;
buf = _bt_getbuf(rel, blk, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
result = P_ISHALFDEAD(opaque);
parent = stack->bts_blkno;
poffset = stack->bts_offset;
- page = BufferGetPage(pbuf);
+ page = BufferGetPage(pbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
maxoff = PageGetMaxOffsetNumber(page);
BTPageOpaque lopaque;
lbuf = _bt_getbuf(rel, leftsib, BT_READ);
- lpage = BufferGetPage(lbuf);
+ lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
/*
for (;;)
{
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
/*
Page lpage;
lbuf = _bt_getbuf(rel, leftsib, BT_READ);
- lpage = BufferGetPage(lbuf);
+ lpage = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
/*
IndexTuple itup;
IndexTupleData trunctuple;
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
Assert(!P_RIGHTMOST(opaque) && !P_ISROOT(opaque) && !P_ISDELETED(opaque) &&
* contents. The test on the next-child downlink is known to sometimes
* fail in the field, though.
*/
- page = BufferGetPage(topparent);
+ page = BufferGetPage(topparent, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
#ifdef USE_ASSERT_CHECKING
* to copy the right sibling's downlink over the target downlink, and then
* delete the following item.
*/
- page = BufferGetPage(topparent);
+ page = BufferGetPage(topparent, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
itemid = PageGetItemId(page, topoff);
* highest internal page in the branch we're deleting. We use the tid of
* the high key to store it.
*/
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
opaque->btpo_flags |= BTP_HALF_DEAD;
XLogRegisterBuffer(0, leafbuf, REGBUF_WILL_INIT);
XLogRegisterBuffer(1, topparent, REGBUF_STANDARD);
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
xlrec.leftblk = opaque->btpo_prev;
xlrec.rightblk = opaque->btpo_next;
recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_MARK_PAGE_HALFDEAD);
- page = BufferGetPage(topparent);
+ page = BufferGetPage(topparent, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
ItemPointer leafhikey;
BlockNumber nextchild;
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
Assert(P_ISLEAF(opaque) && P_ISHALFDEAD(opaque));
/* fetch the block number of the topmost parent's left sibling */
buf = _bt_getbuf(rel, target, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
leftsib = opaque->btpo_prev;
targetlevel = opaque->btpo.level;
if (leftsib != P_NONE)
{
lbuf = _bt_getbuf(rel, leftsib, BT_WRITE);
- page = BufferGetPage(lbuf);
+ page = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
while (P_ISDELETED(opaque) || opaque->btpo_next != target)
{
return false;
}
lbuf = _bt_getbuf(rel, leftsib, BT_WRITE);
- page = BufferGetPage(lbuf);
+ page = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
}
}
* empty page.
*/
LockBuffer(buf, BT_WRITE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
/*
*/
rightsib = opaque->btpo_next;
rbuf = _bt_getbuf(rel, rightsib, BT_WRITE);
- page = BufferGetPage(rbuf);
+ page = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (opaque->btpo_prev != target)
elog(ERROR, "right sibling's left-link doesn't match: "
*/
if (leftsib == P_NONE && rightsib_is_rightmost)
{
- page = BufferGetPage(rbuf);
+ page = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (P_RIGHTMOST(opaque))
{
/* rightsib will be the only one left on the level */
metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
metad = BTPageGetMeta(metapg);
/*
*/
if (BufferIsValid(lbuf))
{
- page = BufferGetPage(lbuf);
+ page = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
Assert(opaque->btpo_next == target);
opaque->btpo_next = rightsib;
}
- page = BufferGetPage(rbuf);
+ page = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
Assert(opaque->btpo_prev == target);
opaque->btpo_prev = leftsib;
* will continue to do so, holding back RecentGlobalXmin, for the duration
* of that scan.
*/
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
opaque->btpo_flags &= ~BTP_HALF_DEAD;
opaque->btpo_flags |= BTP_DELETED;
{
PageSetLSN(metapg, recptr);
}
- page = BufferGetPage(rbuf);
+ page = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
if (BufferIsValid(lbuf))
{
- page = BufferGetPage(lbuf);
+ page = BufferGetPage(lbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
if (target != leafblkno)
{
- page = BufferGetPage(leafbuf);
+ page = BufferGetPage(leafbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
}
buf = ReadBufferExtended(rel, MAIN_FORKNUM, blkno, RBM_NORMAL,
info->strategy);
LockBuffer(buf, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!PageIsNew(page))
{
_bt_checkpage(rel, buf);
static void _bt_saveitem(BTScanOpaque so, int itemIndex,
OffsetNumber offnum, IndexTuple itup);
static bool _bt_steppage(IndexScanDesc scan, ScanDirection dir);
-static Buffer _bt_walk_left(Relation rel, Buffer buf);
+static Buffer _bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot);
static bool _bt_endpoint(IndexScanDesc scan, ScanDirection dir);
static void _bt_drop_lock_and_maybe_pin(IndexScanDesc scan, BTScanPos sp);
/* If index is empty and access = BT_READ, no root page is created. */
if (!BufferIsValid(*bufP))
+ {
return (BTStack) NULL;
+ }
/* Loop iterates once per level descended in the tree */
for (;;)
BT_READ);
/* if this is a leaf page, we're done */
- page = BufferGetPage(*bufP);
+ page = BufferGetPage(*bufP, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (P_ISLEAF(opaque))
break;
for (;;)
{
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (P_RIGHTMOST(opaque))
int32 result,
cmpval;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
low = P_FIRSTDATAKEY(opaque);
*/
Assert(BufferIsValid(so->currPos.buf));
- page = BufferGetPage(so->currPos.buf);
+ page = BufferGetPage(so->currPos.buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
minoff = P_FIRSTDATAKEY(opaque);
maxoff = PageGetMaxOffsetNumber(page);
/* step right one page */
so->currPos.buf = _bt_getbuf(rel, blkno, BT_READ);
/* check for deleted page */
- page = BufferGetPage(so->currPos.buf);
+ page = BufferGetPage(so->currPos.buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (!P_IGNORE(opaque))
{
}
/* Step to next physical page */
- so->currPos.buf = _bt_walk_left(rel, so->currPos.buf);
+ so->currPos.buf = _bt_walk_left(rel, so->currPos.buf,
+ scan->xs_snapshot);
/* if we're physically at end of index, return failure */
if (so->currPos.buf == InvalidBuffer)
* it's not half-dead and contains matching tuples. Else loop back
* and do it all again.
*/
- page = BufferGetPage(so->currPos.buf);
+ page = BufferGetPage(so->currPos.buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (!P_IGNORE(opaque))
{
* again if it's important.
*/
static Buffer
-_bt_walk_left(Relation rel, Buffer buf)
+_bt_walk_left(Relation rel, Buffer buf, Snapshot snapshot)
{
Page page;
BTPageOpaque opaque;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
for (;;)
/* check for interrupts while we're not holding any buffer lock */
CHECK_FOR_INTERRUPTS();
buf = _bt_getbuf(rel, blkno, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
/*
break;
blkno = opaque->btpo_next;
buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
}
/* Return to the original page to see what's up */
buf = _bt_relandgetbuf(rel, buf, obknum, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (P_ISDELETED(opaque))
{
RelationGetRelationName(rel));
blkno = opaque->btpo_next;
buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
if (!P_ISDELETED(opaque))
break;
if (!BufferIsValid(buf))
return InvalidBuffer;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
for (;;)
elog(ERROR, "fell off the end of index \"%s\"",
RelationGetRelationName(rel));
buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
}
blkno = ItemPointerGetBlockNumber(&(itup->t_tid));
buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
}
}
PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
opaque = (BTPageOpaque) PageGetSpecialPointer(page);
Assert(P_ISLEAF(opaque));
*/
LockBuffer(so->currPos.buf, BT_READ);
- page = BufferGetPage(so->currPos.buf);
+ page = BufferGetPage(so->currPos.buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
}
else
{
if (!BufferIsValid(buf))
return;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageGetLSN(page) == so->currPos.lsn)
so->currPos.buf = buf;
else
Assert(len == sizeof(xl_btree_metadata));
Assert(BufferGetBlockNumber(metabuf) == BTREE_METAPAGE);
xlrec = (xl_btree_metadata *) ptr;
- metapg = BufferGetPage(metabuf);
+ metapg = BufferGetPage(metabuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(metapg, BufferGetPageSize(metabuf));
if (XLogReadBufferForRedo(record, block_id, &buf) == BLK_NEEDS_REDO)
{
- Page page = (Page) BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
BTPageOpaque pageop = (BTPageOpaque) PageGetSpecialPointer(page);
Assert((pageop->btpo_flags & BTP_INCOMPLETE_SPLIT) != 0);
Size datalen;
char *datapos = XLogRecGetBlockData(record, 0, &datalen);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageAddItem(page, (Item) datapos, datalen, xlrec->offnum,
false, false) == InvalidOffsetNumber)
/* Reconstruct right (new) sibling page from scratch */
rbuf = XLogInitBufferForRedo(record, 1);
datapos = XLogRecGetBlockData(record, 1, &datalen);
- rpage = (Page) BufferGetPage(rbuf);
+ rpage = BufferGetPage(rbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(rpage, BufferGetPageSize(rbuf));
ropaque = (BTPageOpaque) PageGetSpecialPointer(rpage);
* but it helps debugging. See also _bt_restore_page(), which does
* the same for the right page.
*/
- Page lpage = (Page) BufferGetPage(lbuf);
+ Page lpage = BufferGetPage(lbuf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
BTPageOpaque lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
OffsetNumber off;
Item newitem = NULL;
if (XLogReadBufferForRedo(record, 2, &buffer) == BLK_NEEDS_REDO)
{
- Page page = (Page) BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
BTPageOpaque pageop = (BTPageOpaque) PageGetSpecialPointer(page);
pageop->btpo_prev = rightsib;
ptr = XLogRecGetBlockData(record, 0, &len);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (len > 0)
{
if (!BufferIsValid(ibuffer))
return InvalidTransactionId;
LockBuffer(ibuffer, BT_READ);
- ipage = (Page) BufferGetPage(ibuffer);
+ ipage = BufferGetPage(ibuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Loop through the deleted index items to obtain the TransactionId from
return InvalidTransactionId;
}
LockBuffer(hbuffer, BUFFER_LOCK_SHARE);
- hpage = (Page) BufferGetPage(hbuffer);
+ hpage = BufferGetPage(hbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Look up the heap tuple header that the index tuple points at by
*/
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (XLogRecGetDataLen(record) > SizeOfBtreeDelete)
{
OffsetNumber nextoffset;
BlockNumber rightsib;
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
poffset = xlrec->poffset;
/* Rewrite the leaf page as a halfdead page */
buffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(page, BufferGetPageSize(buffer));
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
/* Fix left-link of right sibling */
if (XLogReadBufferForRedo(record, 2, &buffer) == BLK_NEEDS_REDO)
{
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
pageop->btpo_prev = leftsib;
{
if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
{
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
pageop->btpo_next = rightsib;
/* Rewrite target page as empty deleted page */
buffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(page, BufferGetPageSize(buffer));
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
IndexTupleData trunctuple;
buffer = XLogInitBufferForRedo(record, 3);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(page, BufferGetPageSize(buffer));
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
Size len;
buffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
_bt_pageinit(page, BufferGetPageSize(buffer));
pageop = (BTPageOpaque) PageGetSpecialPointer(page);
/* Find a leaf page that will hold them */
nbuf = SpGistGetBuffer(index, GBUF_LEAF | (isNulls ? GBUF_NULLS : 0),
size, &xlrec.newPage);
- npage = BufferGetPage(nbuf);
+ npage = BufferGetPage(nbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
nblkno = BufferGetBlockNumber(nbuf);
Assert(nblkno != current->blkno);
nodePageSelect = (uint8 *) palloc(sizeof(uint8) * out.nNodes);
curspace = currentFreeSpace;
- newspace = PageGetExactFreeSpace(BufferGetPage(newLeafBuffer));
+ newspace = PageGetExactFreeSpace
+ (BufferGetPage(newLeafBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
for (i = 0; i < out.nNodes; i++)
{
if (leafSizes[i] <= curspace)
/* Repeat the node assignment process --- should succeed now */
curspace = currentFreeSpace;
- newspace = PageGetExactFreeSpace(BufferGetPage(newLeafBuffer));
+ newspace = PageGetExactFreeSpace
+ (BufferGetPage(newLeafBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
for (i = 0; i < out.nNodes; i++)
{
if (leafSizes[i] <= curspace)
it->nextOffset = InvalidOffsetNumber;
/* Insert it on page */
- newoffset = SpGistPageAddNewItem(state, BufferGetPage(leafBuffer),
+ newoffset = SpGistPageAddNewItem(state,
+ BufferGetPage(leafBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
(Item) it, it->size,
&startOffsets[leafPageSelect[i]],
false);
/* Repoint "current" at the new inner tuple */
current->buffer = newInnerBuffer;
current->blkno = BufferGetBlockNumber(current->buffer);
- current->page = BufferGetPage(current->buffer);
+ current->page = BufferGetPage(current->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
xlrec.offnumInner = current->offnum =
SpGistPageAddNewItem(state, current->page,
(Item) innerTuple, innerTuple->size,
/* Update page LSNs on all affected pages */
if (newLeafBuffer != InvalidBuffer)
{
- Page page = BufferGetPage(newLeafBuffer);
-
+ Page page = BufferGetPage(newLeafBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
if (saveCurrent.buffer != InvalidBuffer)
{
- Page page = BufferGetPage(saveCurrent.buffer);
-
+ Page page = BufferGetPage(saveCurrent.buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, recptr);
}
PageSetLSN(current->page, recptr);
if (parent->buffer != InvalidBuffer)
- {
PageSetLSN(parent->page, recptr);
- }
}
END_CRIT_SECTION();
newInnerTuple->size + sizeof(ItemIdData),
&xlrec.newPage);
current->blkno = BufferGetBlockNumber(current->buffer);
- current->page = BufferGetPage(current->buffer);
+ current->page = BufferGetPage(current->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/*
* Let's just make real sure new current isn't same as old. Right now
{
postfixBlkno = BufferGetBlockNumber(newBuffer);
xlrec.offnumPostfix = postfixOffset =
- SpGistPageAddNewItem(state, BufferGetPage(newBuffer),
+ SpGistPageAddNewItem(state,
+ BufferGetPage(newBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
(Item) postfixTuple, postfixTuple->size,
NULL, false);
MarkBufferDirty(newBuffer);
if (newBuffer != InvalidBuffer)
{
- PageSetLSN(BufferGetPage(newBuffer), recptr);
+ PageSetLSN(BufferGetPage(newBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
}
/* inner tuple can be stored on the same page as parent one */
current.buffer = parent.buffer;
}
- current.page = BufferGetPage(current.buffer);
+ current.page = BufferGetPage(current.buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/* should not arrive at a page of the wrong type */
if (isnull ? !SpGistPageStoresNulls(current.page) :
START_CRIT_SECTION();
- SpGistInitMetapage(BufferGetPage(metabuffer));
+ SpGistInitMetapage(BufferGetPage(metabuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
MarkBufferDirty(metabuffer);
SpGistInitBuffer(rootbuffer, SPGIST_LEAF);
MarkBufferDirty(rootbuffer);
recptr = XLogInsert(RM_SPGIST_ID, XLOG_SPGIST_CREATE_INDEX);
- PageSetLSN(BufferGetPage(metabuffer), recptr);
- PageSetLSN(BufferGetPage(rootbuffer), recptr);
- PageSetLSN(BufferGetPage(nullbuffer), recptr);
+ PageSetLSN(BufferGetPage(metabuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
+ PageSetLSN(BufferGetPage(rootbuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
+ PageSetLSN(BufferGetPage(nullbuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), recptr);
}
END_CRIT_SECTION();
*/
static void
spgWalk(Relation index, SpGistScanOpaque so, bool scanWholeIndex,
- storeRes_func storeRes)
+ storeRes_func storeRes, Snapshot snapshot)
{
Buffer buffer = InvalidBuffer;
bool reportedSome = false;
}
/* else new pointer points to the same page, no work needed */
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
isnull = SpGistPageStoresNulls(page) ? true : false;
so->tbm = tbm;
so->ntids = 0;
- spgWalk(scan->indexRelation, so, true, storeBitmap);
+ spgWalk(scan->indexRelation, so, true, storeBitmap, scan->xs_snapshot);
return so->ntids;
}
}
so->iPtr = so->nPtrs = 0;
- spgWalk(scan->indexRelation, so, false, storeGettuple);
+ spgWalk(scan->indexRelation, so, false, storeGettuple,
+ scan->xs_snapshot);
if (so->nPtrs == 0)
break; /* must have completed scan */
metabuffer = ReadBuffer(index, SPGIST_METAPAGE_BLKNO);
LockBuffer(metabuffer, BUFFER_LOCK_SHARE);
- metadata = SpGistPageGetMeta(BufferGetPage(metabuffer));
+ metadata = SpGistPageGetMeta
+ (BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
if (metadata->magicNumber != SPGIST_MAGIC_NUMBER)
elog(ERROR, "index \"%s\" is not an SP-GiST index",
*/
if (ConditionalLockBuffer(buffer))
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
return buffer; /* OK to use, if never initialized */
if (ConditionalLockBuffer(metabuffer))
{
- metadata = SpGistPageGetMeta(BufferGetPage(metabuffer));
+ metadata = SpGistPageGetMeta
+ (BufferGetPage(metabuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST));
metadata->lastUsedPages = cache->lastUsedPages;
MarkBufferDirty(metabuffer);
blkFlags |= GBUF_NULLS;
cache->lastUsedPages.cachedPage[blkFlags].blkno = blkno;
cache->lastUsedPages.cachedPage[blkFlags].freeSpace =
- PageGetExactFreeSpace(BufferGetPage(buffer));
+ PageGetExactFreeSpace
+ (BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
UnlockReleaseBuffer(buffer);
}
}
return allocNewBuffer(index, flags);
}
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page) || SpGistPageIsDeleted(page) || PageIsEmpty(page))
{
SpGistCache *cache = spgGetCache(index);
SpGistLastUsedPage *lup;
int freeSpace;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BlockNumber blkno = BufferGetBlockNumber(buffer);
int flags;
SpGistInitBuffer(Buffer b, uint16 f)
{
Assert(BufferGetPageSize(b) == BLCKSZ);
- SpGistInitPage(BufferGetPage(b), f);
+ SpGistInitPage(BufferGetPage(b, NULL, NULL, BGP_NO_SNAPSHOT_TEST), f);
}
/*
vacuumLeafPage(spgBulkDeleteState *bds, Relation index, Buffer buffer,
bool forPending)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
spgxlogVacuumLeaf xlrec;
OffsetNumber toDead[MaxIndexTuplesPerPage];
OffsetNumber toPlaceholder[MaxIndexTuplesPerPage];
static void
vacuumLeafRoot(spgBulkDeleteState *bds, Relation index, Buffer buffer)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
spgxlogVacuumRoot xlrec;
OffsetNumber toDelete[MaxIndexTuplesPerPage];
OffsetNumber i,
static void
vacuumRedirectAndPlaceholder(Relation index, Buffer buffer)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
SpGistPageOpaque opaque = SpGistPageGetOpaque(page);
OffsetNumber i,
max = PageGetMaxOffsetNumber(page),
buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
RBM_NORMAL, bds->info->strategy);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
{
buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
RBM_NORMAL, bds->info->strategy);
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page) || SpGistPageIsDeleted(page))
{
buffer = XLogInitBufferForRedo(record, 0);
Assert(BufferGetBlockNumber(buffer) == SPGIST_METAPAGE_BLKNO);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
SpGistInitMetapage(page);
PageSetLSN(page, lsn);
MarkBufferDirty(buffer);
buffer = XLogInitBufferForRedo(record, 1);
Assert(BufferGetBlockNumber(buffer) == SPGIST_ROOT_BLKNO);
SpGistInitBuffer(buffer, SPGIST_LEAF);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, lsn);
MarkBufferDirty(buffer);
UnlockReleaseBuffer(buffer);
buffer = XLogInitBufferForRedo(record, 2);
Assert(BufferGetBlockNumber(buffer) == SPGIST_NULL_BLKNO);
SpGistInitBuffer(buffer, SPGIST_LEAF | SPGIST_NULLS);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageSetLSN(page, lsn);
MarkBufferDirty(buffer);
UnlockReleaseBuffer(buffer);
if (action == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* insert new tuple */
if (xldata->offnumLeaf != xldata->offnumHeadLeaf)
XLogRecGetBlockTag(record, 0, NULL, NULL, &blknoLeaf);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
tuple = (SpGistInnerTuple) PageGetItem(page,
PageGetItemId(page, xldata->offnumParent));
{
int i;
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
for (i = 0; i < nInsert; i++)
{
/* Delete tuples from the source page, inserting a redirection pointer */
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
spgPageIndexMultiDelete(&state, page, toDelete, xldata->nMoves,
state.isBuild ? SPGIST_PLACEHOLDER : SPGIST_REDIRECT,
{
SpGistInnerTuple tuple;
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
tuple = (SpGistInnerTuple) PageGetItem(page,
PageGetItemId(page, xldata->offnumParent));
Assert(xldata->parentBlk == -1);
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageIndexTupleDelete(page, xldata->offnum);
if (PageAddItem(page, (Item) innerTuple, innerTupleHdr.size,
action = XLogReadBufferForRedo(record, 1, &buffer);
if (action == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
addOrReplaceTuple(page, (Item) innerTuple,
innerTupleHdr.size, xldata->offnumNew);
{
SpGistDeadTuple dt;
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (state.isBuild)
dt = spgFormDeadTuple(&state, SPGIST_PLACEHOLDER,
{
SpGistInnerTuple parentTuple;
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
parentTuple = (SpGistInnerTuple) PageGetItem(page,
PageGetItemId(page, xldata->offnumParent));
action = XLogReadBufferForRedo(record, 1, &buffer);
if (action == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
addOrReplaceTuple(page, (Item) postfixTuple,
postfixTupleHdr.size, xldata->offnumPostfix);
/* now handle the original page */
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageIndexTupleDelete(page, xldata->offnumPrefix);
if (PageAddItem(page, (Item) prefixTuple, prefixTupleHdr.size,
{
/* just re-init the source page */
srcBuffer = XLogInitBufferForRedo(record, 0);
- srcPage = (Page) BufferGetPage(srcBuffer);
+ srcPage = BufferGetPage(srcBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
SpGistInitBuffer(srcBuffer,
SPGIST_LEAF | (xldata->storesNulls ? SPGIST_NULLS : 0));
srcPage = NULL;
if (XLogReadBufferForRedo(record, 0, &srcBuffer) == BLK_NEEDS_REDO)
{
- srcPage = BufferGetPage(srcBuffer);
+ srcPage = BufferGetPage(srcBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* We have it a bit easier here than in doPickSplit(), because we
{
/* just re-init the dest page */
destBuffer = XLogInitBufferForRedo(record, 1);
- destPage = (Page) BufferGetPage(destBuffer);
+ destPage = BufferGetPage(destBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
SpGistInitBuffer(destBuffer,
SPGIST_LEAF | (xldata->storesNulls ? SPGIST_NULLS : 0));
* full-page-image case, but for safety let's hold it till later.
*/
if (XLogReadBufferForRedo(record, 1, &destBuffer) == BLK_NEEDS_REDO)
- destPage = (Page) BufferGetPage(destBuffer);
+ destPage = BufferGetPage(destBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
else
destPage = NULL; /* don't do any page updates */
}
if (action == BLK_NEEDS_REDO)
{
- page = BufferGetPage(innerBuffer);
+ page = BufferGetPage(innerBuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
addOrReplaceTuple(page, (Item) innerTuple, innerTupleHdr.size,
xldata->offnumInner);
{
SpGistInnerTuple parent;
- page = BufferGetPage(parentBuffer);
+ page = BufferGetPage(parentBuffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
parent = (SpGistInnerTuple) PageGetItem(page,
PageGetItemId(page, xldata->offnumParent));
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
spgPageIndexMultiDelete(&state, page,
toDead, xldata->nDead,
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/* The tuple numbers are in order */
PageIndexMultiDelete(page, toDelete, xldata->nDelete);
if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
SpGistPageOpaque opaque = SpGistPageGetOpaque(page);
int i;
static void
writeDelta(PageData *pageData)
{
- Page page = BufferGetPage(pageData->buffer),
+ Page page = BufferGetPage(pageData->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
image = (Page) pageData->image;
int i,
fragmentBegin = -1,
if (BufferIsInvalid(page->buffer))
{
page->buffer = buffer;
- memcpy(page->image, BufferGetPage(buffer), BLCKSZ);
+ memcpy(page->image, BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), BLCKSZ);
page->dataLen = 0;
page->fullImage = isNew;
return (Page)page->image;
/* Swap current and saved page image. */
memcpy(tmp, page->image, BLCKSZ);
- memcpy(page->image, BufferGetPage(page->buffer), BLCKSZ);
- memcpy(BufferGetPage(page->buffer), tmp, BLCKSZ);
+ memcpy(page->image, BufferGetPage(page->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), BLCKSZ);
+ memcpy(BufferGetPage(page->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), tmp, BLCKSZ);
if (page->fullImage)
{
if (BufferIsInvalid(page->buffer))
continue;
- PageSetLSN(BufferGetPage(page->buffer), lsn);
+ PageSetLSN(BufferGetPage(page->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), lsn);
MarkBufferDirty(page->buffer);
}
END_CRIT_SECTION();
if (BufferIsInvalid(page->buffer))
continue;
- memcpy(BufferGetPage(page->buffer), page->image, BLCKSZ);
+ memcpy(BufferGetPage(page->buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST), page->image, BLCKSZ);
MarkBufferDirty(page->buffer);
}
END_CRIT_SECTION();
Size blockDataSize;
Page page;
- page = BufferGetPage(buffers[block_id]);
+ page = BufferGetPage(buffers[block_id], NULL, NULL, BGP_NO_SNAPSHOT_TEST);
blockData = XLogRecGetBlockData(record, block_id, &blockDataSize);
applyPageRedo(page, blockData, blockDataSize);
regbuf = ®istered_buffers[block_id];
BufferGetTag(buffer, ®buf->rnode, ®buf->forkno, ®buf->block);
- regbuf->page = BufferGetPage(buffer);
+ regbuf->page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
regbuf->flags = flags;
regbuf->rdata_tail = (XLogRecData *) ®buf->rdata_head;
regbuf->rdata_len = 0;
GetFullPageWriteInfo(&RedoRecPtr, &doPageWrites);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (doPageWrites && PageGetLSN(page) <= RedoRecPtr)
return true; /* buffer requires backup */
if (buffer_std)
{
/* Assume we can omit data between pd_lower and pd_upper */
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
uint16 lower = ((PageHeader) page)->pd_lower;
uint16 upper = ((PageHeader) page)->pd_upper;
XLogRecPtr
log_newpage_buffer(Buffer buffer, bool page_std)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
RelFileNode rnode;
ForkNumber forkNum;
BlockNumber blkno;
{
*buf = XLogReadBufferExtended(rnode, forknum, blkno,
get_cleanup_lock ? RBM_ZERO_AND_CLEANUP_LOCK : RBM_ZERO_AND_LOCK);
- page = BufferGetPage(*buf);
+ page = BufferGetPage(*buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!RestoreBlockImage(record, block_id, page))
elog(ERROR, "failed to restore block image");
else
LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
}
- if (lsn <= PageGetLSN(BufferGetPage(*buf)))
+ if (lsn <= PageGetLSN(BufferGetPage(*buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST)))
return BLK_DONE;
else
return BLK_NEEDS_REDO;
if (mode == RBM_NORMAL)
{
/* check that page has been initialized */
- Page page = (Page) BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST);
/*
* We assume that PageIsNew is safe without a lock. During recovery,
*/
if (scan->rs_cblock != root_blkno)
{
- Page page = BufferGetPage(scan->rs_cbuf);
+ Page page = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
heap_get_root_tuples(page, root_offsets);
*/
if (scan->rs_cblock != root_blkno)
{
- Page page = BufferGetPage(scan->rs_cbuf);
+ Page page = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
heap_get_root_tuples(page, root_offsets);
targbuffer = ReadBufferExtended(onerel, MAIN_FORKNUM, targblock,
RBM_NORMAL, vac_strategy);
LockBuffer(targbuffer, BUFFER_LOCK_SHARE);
- targpage = BufferGetPage(targbuffer);
+ targpage = BufferGetPage(targbuffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
maxoffset = PageGetMaxOffsetNumber(targpage);
/* Inner loop over all tuples on the selected page */
buf = ReadBuffer(rel, P_NEW);
Assert(BufferGetBlockNumber(buf) == 0);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
PageInit(page, BufferGetPageSize(buf), sizeof(sequence_magic));
sm = (sequence_magic *) PageGetSpecialPointer(page);
{
xl_seq_rec xlrec;
XLogRecPtr recptr;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
XLogBeginInsert();
XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);
/* lock page' buffer and read tuple */
seq = read_seq_tuple(elm, seqrel, &buf, &seqtuple);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
last = next = result = seq->last_value;
incby = seq->increment_by;
{
xl_seq_rec xlrec;
XLogRecPtr recptr;
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
XLogBeginInsert();
XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);
*buf = ReadBuffer(rel, 0);
LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(*buf);
+ page = BufferGetPage(*buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
sm = (sequence_magic *) PageGetSpecialPointer(page);
if (sm->magic != SEQ_MAGIC)
elog(PANIC, "seq_redo: unknown op code %u", info);
buffer = XLogInitBufferForRedo(record, 0);
- page = (Page) BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* We always reinit the page. However, since this WAL record type is also
*/
LockBuffer(buffer, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buffer);
+ page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
Assert(ItemIdIsNormal(lp));
vacrelstats->scanned_pages++;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
{
&vmbuffer);
/* Now that we've compacted the page, record its available space */
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
freespace = PageGetHeapFreeSpace(page);
UnlockReleaseBuffer(buf);
lazy_vacuum_page(Relation onerel, BlockNumber blkno, Buffer buffer,
int tupindex, LVRelStats *vacrelstats, Buffer *vmbuffer)
{
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber unused[MaxOffsetNumber];
int uncnt = 0;
TransactionId visibility_cutoff_xid;
static bool
lazy_check_needs_freeze(Buffer buf, bool *hastup)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber offnum,
maxoff;
HeapTupleHeader tupleheader;
/* In this phase we only need shared access to the buffer */
LockBuffer(buf, BUFFER_LOCK_SHARE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page) || PageIsEmpty(page))
{
TransactionId *visibility_cutoff_xid,
bool *all_frozen)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
BlockNumber blockno = BufferGetBlockNumber(buf);
OffsetNumber offnum,
maxoff;
* Okay to fetch the tuple
*/
targoffset = scan->rs_vistuples[scan->rs_cindex];
- dp = (Page) BufferGetPage(scan->rs_cbuf);
+ dp = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
lp = PageGetItemId(dp, targoffset);
Assert(ItemIdIsNormal(lp));
* Bitmap is lossy, so we must examine each item pointer on the page.
* But we can ignore HOT chains, since we'll check each tuple anyway.
*/
- Page dp = (Page) BufferGetPage(buffer);
+ Page dp = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
OffsetNumber maxoff = PageGetMaxOffsetNumber(dp);
OffsetNumber offnum;
if (!pagemode)
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
- page = (Page) BufferGetPage(scan->rs_cbuf);
+ page = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
all_visible = PageIsAllVisible(page) && !snapshot->takenDuringRecovery;
maxoffset = PageGetMaxOffsetNumber(page);
if (!pagemode)
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
- page = (Page) BufferGetPage(scan->rs_cbuf);
+ page = BufferGetPage(scan->rs_cbuf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
all_visible = PageIsAllVisible(page) && !snapshot->takenDuringRecovery;
maxoffset = PageGetMaxOffsetNumber(page);
}
BufferGetLSNAtomic(Buffer buffer)
{
BufferDesc *bufHdr = GetBufferDescriptor(buffer - 1);
- char *page = BufferGetPage(buffer);
+ char *page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
XLogRecPtr lsn;
/*
MarkBufferDirtyHint(Buffer buffer, bool buffer_std)
{
BufferDesc *bufHdr;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (!BufferIsValid(buffer))
elog(ERROR, "bad buffer ID: %d", buffer);
buf = XLogReadBufferExtended(rnode, FSM_FORKNUM, blkno, RBM_ZERO_ON_ERROR);
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (PageIsNew(page))
PageInit(page, BLCKSZ, 0);
buf = fsm_readbuf(rel, addr, false);
if (!BufferIsValid(buf))
return 0;
- cat = fsm_get_avail(BufferGetPage(buf), slot);
+ cat = fsm_get_avail(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ slot);
ReleaseBuffer(buf);
return fsm_space_cat_to_avail(cat);
if (!BufferIsValid(buf))
return; /* nothing to do; the FSM was already smaller */
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- fsm_truncate_avail(BufferGetPage(buf), first_removed_slot);
+ fsm_truncate_avail(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ first_removed_slot);
MarkBufferDirtyHint(buf, false);
UnlockReleaseBuffer(buf);
* headers, for example.
*/
buf = ReadBufferExtended(rel, FSM_FORKNUM, blkno, RBM_ZERO_ON_ERROR, NULL);
- if (PageIsNew(BufferGetPage(buf)))
- PageInit(BufferGetPage(buf), BLCKSZ, 0);
+ if (PageIsNew(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST)))
+ PageInit(BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST),
+ BLCKSZ, 0);
return buf;
}
buf = fsm_readbuf(rel, addr, true);
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
if (fsm_set_avail(page, slot, newValue))
MarkBufferDirtyHint(buf, false);
(addr.level == FSM_BOTTOM_LEVEL),
false);
if (slot == -1)
- max_avail = fsm_get_max_avail(BufferGetPage(buf));
+ max_avail =
+ fsm_get_max_avail(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
UnlockReleaseBuffer(buf);
}
else
else
*eof_p = false;
- page = BufferGetPage(buf);
+ page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
/*
* Recurse into children, and fix the information stored about them at
if (fsm_get_avail(page, slot) != child_avail)
{
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
- fsm_set_avail(BufferGetPage(buf), slot, child_avail);
+ fsm_set_avail(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST),
+ slot, child_avail);
MarkBufferDirtyHint(buf, false);
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
}
}
}
- max_avail = fsm_get_max_avail(BufferGetPage(buf));
+ max_avail = fsm_get_max_avail(BufferGetPage(buf, NULL, NULL,
+ BGP_NO_SNAPSHOT_TEST));
/*
* Reset the next slot pointer. This encourages the use of low-numbered
fsm_search_avail(Buffer buf, uint8 minvalue, bool advancenext,
bool exclusive_lock_held)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf, NULL, NULL, BGP_NO_SNAPSHOT_TEST);
FSMPage fsmpage = (FSMPage) PageGetContents(page);
int nodeno;
int target;
#ifndef BUFMGR_H
#define BUFMGR_H
+#include "catalog/catalog.h"
#include "storage/block.h"
#include "storage/buf.h"
#include "storage/bufpage.h"
#include "storage/relfilenode.h"
#include "utils/relcache.h"
+#include "utils/snapmgr.h"
+#include "utils/tqual.h"
typedef void *Block;
* replay; otherwise same as RBM_NORMAL */
} ReadBufferMode;
+/*
+ * Forced choice for whether BufferGetPage() must check snapshot age
+ *
+ * A scan must test for old snapshot, unless the test would be redundant (for
+ * example, to tests already made at a lower level on all code paths).
+ * Positioning for DML or vacuuming does not need this sort of test.
+ */
+typedef enum
+{
+ BGP_NO_SNAPSHOT_TEST, /* Not used for scan, or is redundant */
+ BGP_TEST_FOR_OLD_SNAPSHOT /* Test for old snapshot is needed */
+} BufferGetPageAgeTest;
+
/* forward declared, to avoid having to expose buf_internals.h here */
struct WritebackContext;
* BufferGetPage
* Returns the page associated with a buffer.
*/
-#define BufferGetPage(buffer) ((Page)BufferGetBlock(buffer))
+#define BufferGetPage(buffer, snapshot, relation, agetest) \
+( \
+ AssertMacro((agetest) == BGP_NO_SNAPSHOT_TEST), \
+ ((Page)BufferGetBlock(buffer)) \
+)
/*
* prototypes for functions in bufmgr.c
extern void AtProcExit_LocalBuffers(void);
+extern Page TestForOldSnapshot(Snapshot snapshot, Relation relation, Page page);
+
/* in freelist.c */
extern BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype);
extern void FreeAccessStrategy(BufferAccessStrategy strategy);
projects / postgresql / commitdiff