database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-05 23:56:58 +03:00
Code

Variable renaming in preparation for refactoring

Browse Source 
Rename page -> block and dp -> page where appropriate.  The old naming
mixed up block and page in confusing ways.

Author: Melanie Plageman <melanieplageman@gmail.com>
Discussion: https://www.postgresql.org/message-id/flat/CAAKRu_YSOnhKsDyFcqJsKtBSrd32DP-jjXmv7hL0BPD-z0TGXQ@mail.gmail.com
This commit is contained in:
Peter Eisentraut 2022-11-16 16:17:18 +01:00
parent d1cb4e9f92
commit 8e1db29cdb
3 changed files with 123 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
src/backend/access/heap/heapam.c
View File

@ -373,19 +373,19 @@ heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlk
* which tuples on the page are visible. * which tuples on the page are visible.
*/ */
void void
heapgetpage(TableScanDesc sscan, BlockNumber page) heapgetpage(TableScanDesc sscan, BlockNumber block)
{ {
HeapScanDesc scan = (HeapScanDesc) sscan; HeapScanDesc scan = (HeapScanDesc) sscan;
Buffer buffer; Buffer buffer;
Snapshot snapshot; Snapshot snapshot;
Page dp; Page page;
int lines; int lines;
int ntup; int ntup;
OffsetNumber lineoff; OffsetNumber lineoff;
ItemId lpp; ItemId lpp;
bool all_visible; bool all_visible;
Assert(page < scan->rs_nblocks); Assert(block < scan->rs_nblocks);
/* release previous scan buffer, if any */ /* release previous scan buffer, if any */
if (BufferIsValid(scan->rs_cbuf)) if (BufferIsValid(scan->rs_cbuf))
@ -402,9 +402,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
CHECK_FOR_INTERRUPTS(); CHECK_FOR_INTERRUPTS();
/* read page using selected strategy */ /* read page using selected strategy */
scan->rs_cbuf = ReadBufferExtended(scan->rs_base.rs_rd, MAIN_FORKNUM, page, scan->rs_cbuf = ReadBufferExtended(scan->rs_base.rs_rd, MAIN_FORKNUM, block,
RBM_NORMAL, scan->rs_strategy); RBM_NORMAL, scan->rs_strategy);
scan->rs_cblock = page; scan->rs_cblock = block;
if (!(scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)) if (!(scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE))
return; return;
@ -424,9 +424,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
*/ */
LockBuffer(buffer, BUFFER_LOCK_SHARE); LockBuffer(buffer, BUFFER_LOCK_SHARE);
dp = BufferGetPage(buffer); page = BufferGetPage(buffer);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(dp); lines = PageGetMaxOffsetNumber(page);
ntup = 0; ntup = 0;
/* /*
@ -449,9 +449,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
* full page write. Until we can prove that beyond doubt, let's check each * full page write. Until we can prove that beyond doubt, let's check each
* tuple for visibility the hard way. * tuple for visibility the hard way.
*/ */
all_visible = PageIsAllVisible(dp) && !snapshot->takenDuringRecovery; all_visible = PageIsAllVisible(page) && !snapshot->takenDuringRecovery;
for (lineoff = FirstOffsetNumber, lpp = PageGetItemId(dp, lineoff); for (lineoff = FirstOffsetNumber, lpp = PageGetItemId(page, lineoff);
lineoff <= lines; lineoff <= lines;
lineoff++, lpp++) lineoff++, lpp++)
{ {
@ -461,9 +461,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
bool valid; bool valid;
loctup.t_tableOid = RelationGetRelid(scan->rs_base.rs_rd); loctup.t_tableOid = RelationGetRelid(scan->rs_base.rs_rd);
loctup.t_data = (HeapTupleHeader) PageGetItem(dp, lpp); loctup.t_data = (HeapTupleHeader) PageGetItem(page, lpp);
loctup.t_len = ItemIdGetLength(lpp); loctup.t_len = ItemIdGetLength(lpp);
ItemPointerSet(&(loctup.t_self), page, lineoff); ItemPointerSet(&(loctup.t_self), block, lineoff);
if (all_visible) if (all_visible)
valid = true; valid = true;
@ -516,9 +516,9 @@ heapgettup(HeapScanDesc scan,
HeapTuple tuple = &(scan->rs_ctup); HeapTuple tuple = &(scan->rs_ctup);
Snapshot snapshot = scan->rs_base.rs_snapshot; Snapshot snapshot = scan->rs_base.rs_snapshot;
bool backward = ScanDirectionIsBackward(dir); bool backward = ScanDirectionIsBackward(dir);
BlockNumber page; BlockNumber block;
bool finished; bool finished;
Page dp; Page page;
int lines; int lines;
OffsetNumber lineoff; OffsetNumber lineoff;
int linesleft; int linesleft;
@ -550,11 +550,11 @@ heapgettup(HeapScanDesc scan,
table_block_parallelscan_startblock_init(scan->rs_base.rs_rd, table_block_parallelscan_startblock_init(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd, block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
/* Other processes might have already finished the scan. */ /* Other processes might have already finished the scan. */
if (page == InvalidBlockNumber) if (block == InvalidBlockNumber)
{ {
Assert(!BufferIsValid(scan->rs_cbuf)); Assert(!BufferIsValid(scan->rs_cbuf));
tuple->t_data = NULL; tuple->t_data = NULL;
@ -562,25 +562,25 @@ heapgettup(HeapScanDesc scan,
} }
} }
else else
page = scan->rs_startblock; /* first page */ block = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
lineoff = FirstOffsetNumber; /* first offnum */ lineoff = FirstOffsetNumber; /* first offnum */
scan->rs_inited = true; scan->rs_inited = true;
} }
else else
{ {
/* continue from previously returned page/tuple */ /* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */ block = scan->rs_cblock; /* current page */
lineoff = /* next offnum */ lineoff = /* next offnum */
OffsetNumberNext(ItemPointerGetOffsetNumber(&(tuple->t_self))); OffsetNumberNext(ItemPointerGetOffsetNumber(&(tuple->t_self)));
} }
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE); LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(dp); lines = PageGetMaxOffsetNumber(page);
/* page and lineoff now reference the physically next tid */ /* block and lineoff now reference the physically next tid */
linesleft = lines - lineoff + 1; linesleft = lines - lineoff + 1;
} }
@ -614,24 +614,24 @@ heapgettup(HeapScanDesc scan,
* rs_numblocks if it's been adjusted by heap_setscanlimits(). * rs_numblocks if it's been adjusted by heap_setscanlimits().
*/ */
if (scan->rs_numblocks != InvalidBlockNumber) if (scan->rs_numblocks != InvalidBlockNumber)
page = (scan->rs_startblock + scan->rs_numblocks - 1) % scan->rs_nblocks; block = (scan->rs_startblock + scan->rs_numblocks - 1) % scan->rs_nblocks;
else if (scan->rs_startblock > 0) else if (scan->rs_startblock > 0)
page = scan->rs_startblock - 1; block = scan->rs_startblock - 1;
else else
page = scan->rs_nblocks - 1; block = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
} }
else else
{ {
/* continue from previously returned page/tuple */ /* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */ block = scan->rs_cblock; /* current page */
} }
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE); LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(dp); lines = PageGetMaxOffsetNumber(page);
if (!scan->rs_inited) if (!scan->rs_inited)
{ {
@ -643,14 +643,14 @@ heapgettup(HeapScanDesc scan,
/* /*
* The previous returned tuple may have been vacuumed since the * The previous returned tuple may have been vacuumed since the
* previous scan when we use a non-MVCC snapshot, so we must * previous scan when we use a non-MVCC snapshot, so we must
* re-establish the lineoff <= PageGetMaxOffsetNumber(dp) * re-establish the lineoff <= PageGetMaxOffsetNumber(page)
* invariant * invariant
*/ */
lineoff = /* previous offnum */ lineoff = /* previous offnum */
Min(lines, Min(lines,
OffsetNumberPrev(ItemPointerGetOffsetNumber(&(tuple->t_self)))); OffsetNumberPrev(ItemPointerGetOffsetNumber(&(tuple->t_self))));
} }
/* page and lineoff now reference the physically previous tid */ /* block and lineoff now reference the physically previous tid */
linesleft = lineoff; linesleft = lineoff;
} }
@ -666,18 +666,18 @@ heapgettup(HeapScanDesc scan,
return; return;
} }
page = ItemPointerGetBlockNumber(&(tuple->t_self)); block = ItemPointerGetBlockNumber(&(tuple->t_self));
if (page != scan->rs_cblock) if (block != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
/* Since the tuple was previously fetched, needn't lock page here */ /* Since the tuple was previously fetched, needn't lock page here */
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self)); lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff); lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp)); Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp); tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp); tuple->t_len = ItemIdGetLength(lpp);
return; return;
@ -687,7 +687,7 @@ heapgettup(HeapScanDesc scan,
* advance the scan until we find a qualifying tuple or run out of stuff * advance the scan until we find a qualifying tuple or run out of stuff
* to scan * to scan
*/ */
lpp = PageGetItemId(dp, lineoff); lpp = PageGetItemId(page, lineoff);
for (;;) for (;;)
{ {
/* /*
@ -703,9 +703,9 @@ heapgettup(HeapScanDesc scan,
{ {
bool valid; bool valid;
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp); tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp); tuple->t_len = ItemIdGetLength(lpp);
ItemPointerSet(&(tuple->t_self), page, lineoff); ItemPointerSet(&(tuple->t_self), block, lineoff);
/* /*
* if current tuple qualifies, return it. * if current tuple qualifies, return it.
@ -756,11 +756,11 @@ heapgettup(HeapScanDesc scan,
*/ */
if (backward) if (backward)
{ {
finished = (page == scan->rs_startblock) || finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false); (scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
if (page == 0) if (block == 0)
page = scan->rs_nblocks; block = scan->rs_nblocks;
page--; block--;
} }
else if (scan->rs_base.rs_parallel != NULL) else if (scan->rs_base.rs_parallel != NULL)
{ {
@ -769,16 +769,16 @@ heapgettup(HeapScanDesc scan,
ParallelBlockTableScanWorker pbscanwork = ParallelBlockTableScanWorker pbscanwork =
scan->rs_parallelworkerdata; scan->rs_parallelworkerdata;
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd, block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
finished = (page == InvalidBlockNumber); finished = (block == InvalidBlockNumber);
} }
else else
{ {
page++; block++;
if (page >= scan->rs_nblocks) if (block >= scan->rs_nblocks)
page = 0; block = 0;
finished = (page == scan->rs_startblock) || finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false); (scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
/* /*
@ -794,7 +794,7 @@ heapgettup(HeapScanDesc scan,
* We don't guarantee any specific ordering in general, though. * We don't guarantee any specific ordering in general, though.
*/ */
if (scan->rs_base.rs_flags & SO_ALLOW_SYNC) if (scan->rs_base.rs_flags & SO_ALLOW_SYNC)
ss_report_location(scan->rs_base.rs_rd, page); ss_report_location(scan->rs_base.rs_rd, block);
} }
/* /*
@ -811,23 +811,23 @@ heapgettup(HeapScanDesc scan,
return; return;
} }
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE); LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber((Page) dp); lines = PageGetMaxOffsetNumber(page);
linesleft = lines; linesleft = lines;
if (backward) if (backward)
{ {
lineoff = lines; lineoff = lines;
lpp = PageGetItemId(dp, lines); lpp = PageGetItemId(page, lines);
} }
else else
{ {
lineoff = FirstOffsetNumber; lineoff = FirstOffsetNumber;
lpp = PageGetItemId(dp, FirstOffsetNumber); lpp = PageGetItemId(page, FirstOffsetNumber);
} }
} }
} }
@ -853,9 +853,9 @@ heapgettup_pagemode(HeapScanDesc scan,
{ {
HeapTuple tuple = &(scan->rs_ctup); HeapTuple tuple = &(scan->rs_ctup);
bool backward = ScanDirectionIsBackward(dir); bool backward = ScanDirectionIsBackward(dir);
BlockNumber page; BlockNumber block;
bool finished; bool finished;
Page dp; Page page;
int lines; int lines;
int lineindex; int lineindex;
OffsetNumber lineoff; OffsetNumber lineoff;
@ -888,11 +888,11 @@ heapgettup_pagemode(HeapScanDesc scan,
table_block_parallelscan_startblock_init(scan->rs_base.rs_rd, table_block_parallelscan_startblock_init(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd, block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
/* Other processes might have already finished the scan. */ /* Other processes might have already finished the scan. */
if (page == InvalidBlockNumber) if (block == InvalidBlockNumber)
{ {
Assert(!BufferIsValid(scan->rs_cbuf)); Assert(!BufferIsValid(scan->rs_cbuf));
tuple->t_data = NULL; tuple->t_data = NULL;
@ -900,22 +900,22 @@ heapgettup_pagemode(HeapScanDesc scan,
} }
} }
else else
page = scan->rs_startblock; /* first page */ block = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
lineindex = 0; lineindex = 0;
scan->rs_inited = true; scan->rs_inited = true;
} }
else else
{ {
/* continue from previously returned page/tuple */ /* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */ block = scan->rs_cblock; /* current page */
lineindex = scan->rs_cindex + 1; lineindex = scan->rs_cindex + 1;
} }
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lines = scan->rs_ntuples; lines = scan->rs_ntuples;
/* page and lineindex now reference the next visible tid */ /* block and lineindex now reference the next visible tid */
linesleft = lines - lineindex; linesleft = lines - lineindex;
} }
@ -949,21 +949,21 @@ heapgettup_pagemode(HeapScanDesc scan,
* rs_numblocks if it's been adjusted by heap_setscanlimits(). * rs_numblocks if it's been adjusted by heap_setscanlimits().
*/ */
if (scan->rs_numblocks != InvalidBlockNumber) if (scan->rs_numblocks != InvalidBlockNumber)
page = (scan->rs_startblock + scan->rs_numblocks - 1) % scan->rs_nblocks; block = (scan->rs_startblock + scan->rs_numblocks - 1) % scan->rs_nblocks;
else if (scan->rs_startblock > 0) else if (scan->rs_startblock > 0)
page = scan->rs_startblock - 1; block = scan->rs_startblock - 1;
else else
page = scan->rs_nblocks - 1; block = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
} }
else else
{ {
/* continue from previously returned page/tuple */ /* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */ block = scan->rs_cblock; /* current page */
} }
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lines = scan->rs_ntuples; lines = scan->rs_ntuples;
if (!scan->rs_inited) if (!scan->rs_inited)
@ -975,7 +975,7 @@ heapgettup_pagemode(HeapScanDesc scan,
{ {
lineindex = scan->rs_cindex - 1; lineindex = scan->rs_cindex - 1;
} }
/* page and lineindex now reference the previous visible tid */ /* block and lineindex now reference the previous visible tid */
linesleft = lineindex + 1; linesleft = lineindex + 1;
} }
@ -991,18 +991,18 @@ heapgettup_pagemode(HeapScanDesc scan,
return; return;
} }
page = ItemPointerGetBlockNumber(&(tuple->t_self)); block = ItemPointerGetBlockNumber(&(tuple->t_self));
if (page != scan->rs_cblock) if (block != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
/* Since the tuple was previously fetched, needn't lock page here */ /* Since the tuple was previously fetched, needn't lock page here */
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self)); lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff); lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp)); Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp); tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp); tuple->t_len = ItemIdGetLength(lpp);
/* check that rs_cindex is in sync */ /* check that rs_cindex is in sync */
@ -1021,12 +1021,12 @@ heapgettup_pagemode(HeapScanDesc scan,
while (linesleft > 0) while (linesleft > 0)
{ {
lineoff = scan->rs_vistuples[lineindex]; lineoff = scan->rs_vistuples[lineindex];
lpp = PageGetItemId(dp, lineoff); lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp)); Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp); tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp); tuple->t_len = ItemIdGetLength(lpp);
ItemPointerSet(&(tuple->t_self), page, lineoff); ItemPointerSet(&(tuple->t_self), block, lineoff);
/* /*
* if current tuple qualifies, return it. * if current tuple qualifies, return it.
@ -1065,11 +1065,11 @@ heapgettup_pagemode(HeapScanDesc scan,
*/ */
if (backward) if (backward)
{ {
finished = (page == scan->rs_startblock) || finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false); (scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
if (page == 0) if (block == 0)
page = scan->rs_nblocks; block = scan->rs_nblocks;
page--; block--;
} }
else if (scan->rs_base.rs_parallel != NULL) else if (scan->rs_base.rs_parallel != NULL)
{ {
@ -1078,16 +1078,16 @@ heapgettup_pagemode(HeapScanDesc scan,
ParallelBlockTableScanWorker pbscanwork = ParallelBlockTableScanWorker pbscanwork =
scan->rs_parallelworkerdata; scan->rs_parallelworkerdata;
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd, block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan); pbscanwork, pbscan);
finished = (page == InvalidBlockNumber); finished = (block == InvalidBlockNumber);
} }
else else
{ {
page++; block++;
if (page >= scan->rs_nblocks) if (block >= scan->rs_nblocks)
page = 0; block = 0;
finished = (page == scan->rs_startblock) || finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false); (scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
/* /*
@ -1103,7 +1103,7 @@ heapgettup_pagemode(HeapScanDesc scan,
* We don't guarantee any specific ordering in general, though. * We don't guarantee any specific ordering in general, though.
*/ */
if (scan->rs_base.rs_flags & SO_ALLOW_SYNC) if (scan->rs_base.rs_flags & SO_ALLOW_SYNC)
ss_report_location(scan->rs_base.rs_rd, page); ss_report_location(scan->rs_base.rs_rd, block);
} }
/* /*
@ -1120,10 +1120,10 @@ heapgettup_pagemode(HeapScanDesc scan,
return; return;
} }
heapgetpage((TableScanDesc) scan, page); heapgetpage((TableScanDesc) scan, block);
dp = BufferGetPage(scan->rs_cbuf); page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp); TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lines = scan->rs_ntuples; lines = scan->rs_ntuples;
linesleft = lines; linesleft = lines;
if (backward) if (backward)
@ -1680,7 +1680,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
Snapshot snapshot, HeapTuple heapTuple, Snapshot snapshot, HeapTuple heapTuple,
bool *all_dead, bool first_call) bool *all_dead, bool first_call)
{ {
Page dp = (Page) BufferGetPage(buffer); Page page = BufferGetPage(buffer);
TransactionId prev_xmax = InvalidTransactionId; TransactionId prev_xmax = InvalidTransactionId;
BlockNumber blkno; BlockNumber blkno;
OffsetNumber offnum; OffsetNumber offnum;
@ -1708,10 +1708,10 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
ItemId lp; ItemId lp;
/* check for bogus TID */ /* check for bogus TID */
if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp)) if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
break; break;
lp = PageGetItemId(dp, offnum); lp = PageGetItemId(page, offnum);
/* check for unused, dead, or redirected items */ /* check for unused, dead, or redirected items */
if (!ItemIdIsNormal(lp)) if (!ItemIdIsNormal(lp))
@ -1734,7 +1734,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
* because the SSI checks and the *Satisfies routine for historical * because the SSI checks and the *Satisfies routine for historical
* MVCC snapshots need the correct tid to decide about the visibility. * MVCC snapshots need the correct tid to decide about the visibility.
*/ */
heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp); heapTuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
heapTuple->t_len = ItemIdGetLength(lp); heapTuple->t_len = ItemIdGetLength(lp);
heapTuple->t_tableOid = RelationGetRelid(relation); heapTuple->t_tableOid = RelationGetRelid(relation);
ItemPointerSet(&heapTuple->t_self, blkno, offnum); ItemPointerSet(&heapTuple->t_self, blkno, offnum);

28
src/backend/access/heap/heapam_handler.c
View File

@ -2109,7 +2109,7 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
TBMIterateResult *tbmres) TBMIterateResult *tbmres)
{ {
HeapScanDesc hscan = (HeapScanDesc) scan; HeapScanDesc hscan = (HeapScanDesc) scan;
BlockNumber page = tbmres->blockno; BlockNumber block = tbmres->blockno;
Buffer buffer; Buffer buffer;
Snapshot snapshot; Snapshot snapshot;
int ntup; int ntup;
@ -2123,7 +2123,7 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
* only hold an AccessShareLock, and it could be inserts from this * only hold an AccessShareLock, and it could be inserts from this
* backend). * backend).
*/ */
if (page >= hscan->rs_nblocks) if (block >= hscan->rs_nblocks)
return false; return false;
/* /*
@ -2131,8 +2131,8 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
*/ */
hscan->rs_cbuf = ReleaseAndReadBuffer(hscan->rs_cbuf, hscan->rs_cbuf = ReleaseAndReadBuffer(hscan->rs_cbuf,
scan->rs_rd, scan->rs_rd,
page); block);
hscan->rs_cblock = page; hscan->rs_cblock = block;
buffer = hscan->rs_cbuf; buffer = hscan->rs_cbuf;
snapshot = scan->rs_snapshot; snapshot = scan->rs_snapshot;
@ -2168,7 +2168,7 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
ItemPointerData tid; ItemPointerData tid;
HeapTupleData heapTuple; HeapTupleData heapTuple;
ItemPointerSet(&tid, page, offnum); ItemPointerSet(&tid, block, offnum);
if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot, if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
&heapTuple, NULL, true)) &heapTuple, NULL, true))
hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid); hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
@ -2180,8 +2180,8 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
* Bitmap is lossy, so we must examine each line pointer on the page. * Bitmap is lossy, so we must examine each line pointer on the page.
* But we can ignore HOT chains, since we'll check each tuple anyway. * But we can ignore HOT chains, since we'll check each tuple anyway.
*/ */
Page dp = (Page) BufferGetPage(buffer); Page page = BufferGetPage(buffer);
OffsetNumber maxoff = PageGetMaxOffsetNumber(dp); OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
OffsetNumber offnum; OffsetNumber offnum;
for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum)) for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
@ -2190,13 +2190,13 @@ heapam_scan_bitmap_next_block(TableScanDesc scan,
HeapTupleData loctup; HeapTupleData loctup;
bool valid; bool valid;
lp = PageGetItemId(dp, offnum); lp = PageGetItemId(page, offnum);
if (!ItemIdIsNormal(lp)) if (!ItemIdIsNormal(lp))
continue; continue;
loctup.t_data = (HeapTupleHeader) PageGetItem(dp, lp); loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
loctup.t_len = ItemIdGetLength(lp); loctup.t_len = ItemIdGetLength(lp);
loctup.t_tableOid = scan->rs_rd->rd_id; loctup.t_tableOid = scan->rs_rd->rd_id;
ItemPointerSet(&loctup.t_self, page, offnum); ItemPointerSet(&loctup.t_self, block, offnum);
valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer); valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
if (valid) if (valid)
{ {
@ -2224,7 +2224,7 @@ heapam_scan_bitmap_next_tuple(TableScanDesc scan,
{ {
HeapScanDesc hscan = (HeapScanDesc) scan; HeapScanDesc hscan = (HeapScanDesc) scan;
OffsetNumber targoffset; OffsetNumber targoffset;
Page dp; Page page;
ItemId lp; ItemId lp;
/* /*
@ -2234,11 +2234,11 @@ heapam_scan_bitmap_next_tuple(TableScanDesc scan,
return false; return false;
targoffset = hscan->rs_vistuples[hscan->rs_cindex]; targoffset = hscan->rs_vistuples[hscan->rs_cindex];
dp = (Page) BufferGetPage(hscan->rs_cbuf); page = BufferGetPage(hscan->rs_cbuf);
lp = PageGetItemId(dp, targoffset); lp = PageGetItemId(page, targoffset);
Assert(ItemIdIsNormal(lp)); Assert(ItemIdIsNormal(lp));
hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(dp, lp); hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
hscan->rs_ctup.t_len = ItemIdGetLength(lp); hscan->rs_ctup.t_len = ItemIdGetLength(lp);
hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id; hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset); ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);

2
src/include/access/heapam.h
View File

@ -133,7 +133,7 @@ extern TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot,
uint32 flags); uint32 flags);
extern void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, extern void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk,
BlockNumber numBlks); BlockNumber numBlks);
extern void heapgetpage(TableScanDesc sscan, BlockNumber page); extern void heapgetpage(TableScanDesc sscan, BlockNumber block);
extern void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params, extern void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params,
bool allow_strat, bool allow_sync, bool allow_pagemode); bool allow_strat, bool allow_sync, bool allow_pagemode);
extern void heap_endscan(TableScanDesc sscan); extern void heap_endscan(TableScanDesc sscan);