open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
pull/138/head^2
Peter Eisentraut 3 years ago
parent d1cb4e9f92
commit 8e1db29cdb
3 changed files with 123 additions and 123 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 216
      src/backend/access/heap/heapam.c
  2. 28
      src/backend/access/heap/heapam_handler.c
  3. 2
      src/include/access/heapam.h

216
src/backend/access/heap/heapam.c
Unescape View File

@ -373,19 +373,19 @@ heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlk
* which tuples on the page are visible.
*/
void
heapgetpage(TableScanDesc sscan, BlockNumber page)
heapgetpage(TableScanDesc sscan, BlockNumber block)
{
HeapScanDesc scan = (HeapScanDesc) sscan;
Buffer buffer;
Snapshot snapshot;
Page dp;
Page page;
int lines;
int ntup;
OffsetNumber lineoff;
ItemId lpp;
bool all_visible;
Assert(page < scan->rs_nblocks);
Assert(block < scan->rs_nblocks);
/* release previous scan buffer, if any */
if (BufferIsValid(scan->rs_cbuf))
@ -402,9 +402,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
CHECK_FOR_INTERRUPTS();
/* 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);
scan->rs_cblock = page;
scan->rs_cblock = block;
if (!(scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE))
return;
@ -424,9 +424,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
*/
LockBuffer(buffer, BUFFER_LOCK_SHARE);
dp = BufferGetPage(buffer);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp);
lines = PageGetMaxOffsetNumber(dp);
page = BufferGetPage(buffer);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(page);
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
* 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++, lpp++)
{
@ -461,9 +461,9 @@ heapgetpage(TableScanDesc sscan, BlockNumber page)
bool valid;
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);
ItemPointerSet(&(loctup.t_self), page, lineoff);
ItemPointerSet(&(loctup.t_self), block, lineoff);
if (all_visible)
valid = true;
@ -516,9 +516,9 @@ heapgettup(HeapScanDesc scan,
HeapTuple tuple = &(scan->rs_ctup);
Snapshot snapshot = scan->rs_base.rs_snapshot;
bool backward = ScanDirectionIsBackward(dir);
BlockNumber page;
BlockNumber block;
bool finished;
Page dp;
Page page;
int lines;
OffsetNumber lineoff;
int linesleft;
@ -550,11 +550,11 @@ heapgettup(HeapScanDesc scan,
table_block_parallelscan_startblock_init(scan->rs_base.rs_rd,
pbscanwork, pbscan);
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan);
block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan);
/* Other processes might have already finished the scan. */
if (page == InvalidBlockNumber)
if (block == InvalidBlockNumber)
{
Assert(!BufferIsValid(scan->rs_cbuf));
tuple->t_data = NULL;
@ -562,25 +562,25 @@ heapgettup(HeapScanDesc scan,
}
}
else
page = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, page);
block = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, block);
lineoff = FirstOffsetNumber; /* first offnum */
scan->rs_inited = true;
}
else
{
/* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */
block = scan->rs_cblock; /* current page */
lineoff = /* next offnum */
OffsetNumberNext(ItemPointerGetOffsetNumber(&(tuple->t_self)));
}
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp);
lines = PageGetMaxOffsetNumber(dp);
/* page and lineoff now reference the physically next tid */
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(page);
/* block and lineoff now reference the physically next tid */
linesleft = lines - lineoff + 1;
}
@ -614,24 +614,24 @@ heapgettup(HeapScanDesc scan,
* rs_numblocks if it's been adjusted by heap_setscanlimits().
*/
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)
page = scan->rs_startblock - 1;
block = scan->rs_startblock - 1;
else
page = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, page);
block = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, block);
}
else
{
/* 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);
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp);
lines = PageGetMaxOffsetNumber(dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(page);
if (!scan->rs_inited)
{
@ -643,14 +643,14 @@ heapgettup(HeapScanDesc scan,
/*
* The previous returned tuple may have been vacuumed since the
* 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
*/
lineoff = /* previous offnum */
Min(lines,
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;
}
@ -666,18 +666,18 @@ heapgettup(HeapScanDesc scan,
return;
}
page = ItemPointerGetBlockNumber(&(tuple->t_self));
if (page != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, page);
block = ItemPointerGetBlockNumber(&(tuple->t_self));
if (block != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, block);
/* Since the tuple was previously fetched, needn't lock page here */
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff);
lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp);
tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp);
return;
@ -687,7 +687,7 @@ heapgettup(HeapScanDesc scan,
* advance the scan until we find a qualifying tuple or run out of stuff
* to scan
*/
lpp = PageGetItemId(dp, lineoff);
lpp = PageGetItemId(page, lineoff);
for (;;)
{
/*
@ -703,9 +703,9 @@ heapgettup(HeapScanDesc scan,
{
bool valid;
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp);
tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp);
ItemPointerSet(&(tuple->t_self), page, lineoff);
ItemPointerSet(&(tuple->t_self), block, lineoff);
/*
* if current tuple qualifies, return it.
@ -756,11 +756,11 @@ heapgettup(HeapScanDesc scan,
*/
if (backward)
{
finished = (page == scan->rs_startblock) ||
finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
if (page == 0)
page = scan->rs_nblocks;
page--;
if (block == 0)
block = scan->rs_nblocks;
block--;
}
else if (scan->rs_base.rs_parallel != NULL)
{
@ -769,16 +769,16 @@ heapgettup(HeapScanDesc scan,
ParallelBlockTableScanWorker pbscanwork =
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);
finished = (page == InvalidBlockNumber);
finished = (block == InvalidBlockNumber);
}
else
{
page++;
if (page >= scan->rs_nblocks)
page = 0;
finished = (page == scan->rs_startblock) ||
block++;
if (block >= scan->rs_nblocks)
block = 0;
finished = (block == scan->rs_startblock) ||
(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.
*/
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;
}
heapgetpage((TableScanDesc) scan, page);
heapgetpage((TableScanDesc) scan, block);
LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, dp);
lines = PageGetMaxOffsetNumber((Page) dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
lines = PageGetMaxOffsetNumber(page);
linesleft = lines;
if (backward)
{
lineoff = lines;
lpp = PageGetItemId(dp, lines);
lpp = PageGetItemId(page, lines);
}
else
{
lineoff = FirstOffsetNumber;
lpp = PageGetItemId(dp, FirstOffsetNumber);
lpp = PageGetItemId(page, FirstOffsetNumber);
}
}
}
@ -853,9 +853,9 @@ heapgettup_pagemode(HeapScanDesc scan,
{
HeapTuple tuple = &(scan->rs_ctup);
bool backward = ScanDirectionIsBackward(dir);
BlockNumber page;
BlockNumber block;
bool finished;
Page dp;
Page page;
int lines;
int lineindex;
OffsetNumber lineoff;
@ -888,11 +888,11 @@ heapgettup_pagemode(HeapScanDesc scan,
table_block_parallelscan_startblock_init(scan->rs_base.rs_rd,
pbscanwork, pbscan);
page = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan);
block = table_block_parallelscan_nextpage(scan->rs_base.rs_rd,
pbscanwork, pbscan);
/* Other processes might have already finished the scan. */
if (page == InvalidBlockNumber)
if (block == InvalidBlockNumber)
{
Assert(!BufferIsValid(scan->rs_cbuf));
tuple->t_data = NULL;
@ -900,22 +900,22 @@ heapgettup_pagemode(HeapScanDesc scan,
}
}
else
page = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, page);
block = scan->rs_startblock; /* first page */
heapgetpage((TableScanDesc) scan, block);
lineindex = 0;
scan->rs_inited = true;
}
else
{
/* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */
block = scan->rs_cblock; /* current page */
lineindex = scan->rs_cindex + 1;
}
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
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;
}
@ -949,21 +949,21 @@ heapgettup_pagemode(HeapScanDesc scan,
* rs_numblocks if it's been adjusted by heap_setscanlimits().
*/
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)
page = scan->rs_startblock - 1;
block = scan->rs_startblock - 1;
else
page = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, page);
block = scan->rs_nblocks - 1;
heapgetpage((TableScanDesc) scan, block);
}
else
{
/* continue from previously returned page/tuple */
page = scan->rs_cblock; /* current page */
block = scan->rs_cblock; /* current page */
}
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lines = scan->rs_ntuples;
if (!scan->rs_inited)
@ -975,7 +975,7 @@ heapgettup_pagemode(HeapScanDesc scan,
{
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;
}
@ -991,18 +991,18 @@ heapgettup_pagemode(HeapScanDesc scan,
return;
}
page = ItemPointerGetBlockNumber(&(tuple->t_self));
if (page != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, page);
block = ItemPointerGetBlockNumber(&(tuple->t_self));
if (block != scan->rs_cblock)
heapgetpage((TableScanDesc) scan, block);
/* Since the tuple was previously fetched, needn't lock page here */
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lineoff = ItemPointerGetOffsetNumber(&(tuple->t_self));
lpp = PageGetItemId(dp, lineoff);
lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp);
tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp);
/* check that rs_cindex is in sync */
@ -1021,12 +1021,12 @@ heapgettup_pagemode(HeapScanDesc scan,
while (linesleft > 0)
{
lineoff = scan->rs_vistuples[lineindex];
lpp = PageGetItemId(dp, lineoff);
lpp = PageGetItemId(page, lineoff);
Assert(ItemIdIsNormal(lpp));
tuple->t_data = (HeapTupleHeader) PageGetItem(dp, lpp);
tuple->t_data = (HeapTupleHeader) PageGetItem(page, lpp);
tuple->t_len = ItemIdGetLength(lpp);
ItemPointerSet(&(tuple->t_self), page, lineoff);
ItemPointerSet(&(tuple->t_self), block, lineoff);
/*
* if current tuple qualifies, return it.
@ -1065,11 +1065,11 @@ heapgettup_pagemode(HeapScanDesc scan,
*/
if (backward)
{
finished = (page == scan->rs_startblock) ||
finished = (block == scan->rs_startblock) ||
(scan->rs_numblocks != InvalidBlockNumber ? --scan->rs_numblocks == 0 : false);
if (page == 0)
page = scan->rs_nblocks;
page--;
if (block == 0)
block = scan->rs_nblocks;
block--;
}
else if (scan->rs_base.rs_parallel != NULL)
{
@ -1078,16 +1078,16 @@ heapgettup_pagemode(HeapScanDesc scan,
ParallelBlockTableScanWorker pbscanwork =
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);
finished = (page == InvalidBlockNumber);
finished = (block == InvalidBlockNumber);
}
else
{
page++;
if (page >= scan->rs_nblocks)
page = 0;
finished = (page == scan->rs_startblock) ||
block++;
if (block >= scan->rs_nblocks)
block = 0;
finished = (block == scan->rs_startblock) ||
(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.
*/
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;
}
heapgetpage((TableScanDesc) scan, page);
heapgetpage((TableScanDesc) scan, block);
dp = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, dp);
page = BufferGetPage(scan->rs_cbuf);
TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
lines = scan->rs_ntuples;
linesleft = lines;
if (backward)
@ -1680,7 +1680,7 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
Snapshot snapshot, HeapTuple heapTuple,
bool *all_dead, bool first_call)
{
Page dp = (Page) BufferGetPage(buffer);
Page page = BufferGetPage(buffer);
TransactionId prev_xmax = InvalidTransactionId;
BlockNumber blkno;
OffsetNumber offnum;
@ -1708,10 +1708,10 @@ heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer,
ItemId lp;
/* check for bogus TID */
if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
break;
lp = PageGetItemId(dp, offnum);
lp = PageGetItemId(page, offnum);
/* check for unused, dead, or redirected items */
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
* 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_tableOid = RelationGetRelid(relation);
ItemPointerSet(&heapTuple->t_self, blkno, offnum);

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

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

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

@ -133,7 +133,7 @@ extern TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot,
uint32 flags);
extern void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk,
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,
bool allow_strat, bool allow_sync, bool allow_pagemode);
extern void heap_endscan(TableScanDesc sscan);

Write Preview
Loading…
Cancel
Save