Add helper functions to simplify heapgettup code

Here we add heapgettup_start_page() and heapgettup_continue_page() to
simplify the code in the heapgettup() function.

Author: Melanie Plageman
Reviewed-by: David Rowley
Discussion: https://postgr.es/m/CAAKRu_bvkhka0CZQun28KTqhuUh5ZqY=_T8QEqZqOL02rpi2bw@mail.gmail.com

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ec6b7962c50f848c2aac41495d1a3ff482fc7db0..57ff13ee8df41fd872cab6deee292be857076ce5 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -544,6 +544,82 @@ heapgettup_initial_block(HeapScanDesc scan, ScanDirection dir)
    }
 }
 
+
+/*
+ * heapgettup_start_page - helper function for heapgettup()
+ *
+ * Return the next page to scan based on the scan->rs_cbuf and set *linesleft
+ * to the number of tuples on this page.  Also set *lineoff to the first
+ * offset to scan with forward scans getting the first offset and backward
+ * getting the final offset on the page.
+ */
+static Page
+heapgettup_start_page(HeapScanDesc scan, ScanDirection dir, int *linesleft,
+                     OffsetNumber *lineoff)
+{
+   Page        page;
+
+   Assert(scan->rs_inited);
+   Assert(BufferIsValid(scan->rs_cbuf));
+
+   /* Caller is responsible for ensuring buffer is locked if needed */
+   page = BufferGetPage(scan->rs_cbuf);
+
+   TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
+
+   *linesleft = PageGetMaxOffsetNumber((Page) page) - FirstOffsetNumber + 1;
+
+   if (ScanDirectionIsForward(dir))
+       *lineoff = FirstOffsetNumber;
+   else
+       *lineoff = (OffsetNumber) (*linesleft);
+
+   /* lineoff now references the physically previous or next tid */
+   return page;
+}
+
+
+/*
+ * heapgettup_continue_page - helper function for heapgettup()
+ *
+ * Return the next page to scan based on the scan->rs_cbuf and set *linesleft
+ * to the number of tuples left to scan on this page.  Also set *lineoff to
+ * the next offset to scan according to the ScanDirection in 'dir'.
+ */
+static inline Page
+heapgettup_continue_page(HeapScanDesc scan, ScanDirection dir, int *linesleft,
+                        OffsetNumber *lineoff)
+{
+   Page        page;
+
+   Assert(scan->rs_inited);
+   Assert(BufferIsValid(scan->rs_cbuf));
+
+   /* Caller is responsible for ensuring buffer is locked if needed */
+   page = BufferGetPage(scan->rs_cbuf);
+
+   TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd, page);
+
+   if (ScanDirectionIsForward(dir))
+   {
+       *lineoff = OffsetNumberNext(scan->rs_coffset);
+       *linesleft = PageGetMaxOffsetNumber(page) - (*lineoff) + 1;
+   }
+   else
+   {
+       /*
+        * 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(page) invariant
+        */
+       *lineoff = Min(PageGetMaxOffsetNumber(page), OffsetNumberPrev(scan->rs_coffset));
+       *linesleft = *lineoff;
+   }
+
+   /* lineoff now references the physically previous or next tid */
+   return page;
+}
+
 /* ----------------
  *     heapgettup - fetch next heap tuple
  *
@@ -571,7 +647,6 @@ heapgettup(HeapScanDesc scan,
           ScanKey key)
 {
    HeapTuple   tuple = &(scan->rs_ctup);
-   Snapshot    snapshot = scan->rs_base.rs_snapshot;
    bool        backward = ScanDirectionIsBackward(dir);
    BlockNumber block;
    bool        finished;
@@ -595,21 +670,12 @@ heapgettup(HeapScanDesc scan,
            tuple->t_data = NULL;
            return;
        }
+       scan->rs_inited = true;
 
        heapgetpage((TableScanDesc) scan, block);
 
        LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
-       page = BufferGetPage(scan->rs_cbuf);
-       TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
-
-       linesleft = PageGetMaxOffsetNumber(page) - FirstOffsetNumber + 1;
-
-       if (ScanDirectionIsForward(dir))
-           lineoff = FirstOffsetNumber;    /* first offnum */
-       else
-           lineoff = (OffsetNumber) linesleft;
-
-       scan->rs_inited = true;
+       page = heapgettup_start_page(scan, dir, &linesleft, &lineoff);
    }
    else
    {
@@ -617,26 +683,7 @@ heapgettup(HeapScanDesc scan,
        block = scan->rs_cblock;
 
        LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
-       page = BufferGetPage(scan->rs_cbuf);
-       TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
-
-       if (ScanDirectionIsForward(dir))
-       {
-           lineoff = OffsetNumberNext(scan->rs_coffset);
-           linesleft = PageGetMaxOffsetNumber(page) - lineoff + 1;
-       }
-       else
-       {
-           /*
-            * 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(page)
-            * invariant
-            */
-           lineoff = Min(PageGetMaxOffsetNumber(page),
-                         OffsetNumberPrev(scan->rs_coffset));
-           linesleft = lineoff;
-       }
+       page = heapgettup_continue_page(scan, dir, &linesleft, &lineoff);
    }
 
    /*
@@ -667,12 +714,12 @@ heapgettup(HeapScanDesc scan,
                 * if current tuple qualifies, return it.
                 */
                valid = HeapTupleSatisfiesVisibility(tuple,
-                                                    snapshot,
+                                                    scan->rs_base.rs_snapshot,
                                                     scan->rs_cbuf);
 
                HeapCheckForSerializableConflictOut(valid, scan->rs_base.rs_rd,
                                                    tuple, scan->rs_cbuf,
-                                                   snapshot);
+                                                   scan->rs_base.rs_snapshot);
 
                if (valid && key != NULL)
                    valid = HeapKeyTest(tuple, RelationGetDescr(scan->rs_base.rs_rd),
@@ -773,7 +820,8 @@ heapgettup(HeapScanDesc scan,
        LockBuffer(scan->rs_cbuf, BUFFER_LOCK_SHARE);
 
        page = BufferGetPage(scan->rs_cbuf);
-       TestForOldSnapshot(snapshot, scan->rs_base.rs_rd, page);
+       TestForOldSnapshot(scan->rs_base.rs_snapshot, scan->rs_base.rs_rd,
+                          page);
        linesleft = PageGetMaxOffsetNumber(page);
        if (backward)
        {