Variable renaming in preparation for refactoring

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

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 6eff40a315dc48b331e535235582db3dc46bded1..2e5bb7e9c2e48732442fb4f8219ac2fb97e7aa31 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -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);

diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c
index 103ddbd9788bdb51673d73c5f9a55133f3bb30d0..ab1bcf3522d68220dda45da46bdad657c1c4198e 100644 (file)
--- a/src/backend/access/heap/heapam_handler.c
+++ b/src/backend/access/heap/heapam_handler.c
@@ -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);

diff --git a/src/include/access/heapam.h b/src/include/access/heapam.h
index ebe723abb063bc85d367070c706144c5f127cb30..810baaf9d0833802c6e8b80b14b256cca8378919 100644 (file)
--- a/src/include/access/heapam.h
+++ b/src/include/access/heapam.h
@@ -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);