Remove hastup from LVPagePruneState.

Instead, just have lazy_scan_prune() and lazy_scan_noprune() update
LVRelState->nonempty_pages directly. This makes the two functions
more similar and also removes makes lazy_scan_noprune need one fewer
output parameters.

Melanie Plageman, reviewed by Andres Freund, Michael Paquier, and me

Discussion: http://postgr.es/m/CAAKRu_btji_wQdg=ok-5E4v_bGVxKYnnFFe7RA6Frc1EcOwtSg@mail.gmail.com

diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index abbba8947faded31e3275720157757a25570813f..b63cad1335f1944c8aac2dc0366038721599d59f 100644 (file)
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -217,7 +217,6 @@ typedef struct LVRelState
  */
 typedef struct LVPagePruneState
 {
-   bool        hastup;         /* Page prevents rel truncation? */
    bool        has_lpdead_items;   /* includes existing LP_DEAD items */
 
    /*
@@ -253,7 +252,7 @@ static void lazy_scan_prune(LVRelState *vacrel, Buffer buf,
                            LVPagePruneState *prunestate);
 static bool lazy_scan_noprune(LVRelState *vacrel, Buffer buf,
                              BlockNumber blkno, Page page,
-                             bool *hastup, bool *recordfreespace);
+                             bool *recordfreespace);
 static void lazy_vacuum(LVRelState *vacrel);
 static bool lazy_vacuum_all_indexes(LVRelState *vacrel);
 static void lazy_vacuum_heap_rel(LVRelState *vacrel);
@@ -959,8 +958,7 @@ lazy_scan_heap(LVRelState *vacrel)
        page = BufferGetPage(buf);
        if (!ConditionalLockBufferForCleanup(buf))
        {
-           bool        hastup,
-                       recordfreespace;
+           bool        recordfreespace;
 
            LockBuffer(buf, BUFFER_LOCK_SHARE);
 
@@ -972,20 +970,21 @@ lazy_scan_heap(LVRelState *vacrel)
                continue;
            }
 
-           /* Collect LP_DEAD items in dead_items array, count tuples */
-           if (lazy_scan_noprune(vacrel, buf, blkno, page, &hastup,
+           /*
+            * Collect LP_DEAD items in dead_items array, count tuples,
+            * determine if rel truncation is safe
+            */
+           if (lazy_scan_noprune(vacrel, buf, blkno, page,
                                  &recordfreespace))
            {
                Size        freespace = 0;
 
                /*
                 * Processed page successfully (without cleanup lock) -- just
-                * need to perform rel truncation and FSM steps, much like the
-                * lazy_scan_prune case.  Don't bother trying to match its
-                * visibility map setting steps, though.
+                * need to update the FSM, much like the lazy_scan_prune case.
+                * Don't bother trying to match its visibility map setting
+                * steps, though.
                 */
-               if (hastup)
-                   vacrel->nonempty_pages = blkno + 1;
                if (recordfreespace)
                    freespace = PageGetHeapFreeSpace(page);
                UnlockReleaseBuffer(buf);
@@ -1017,16 +1016,13 @@ lazy_scan_heap(LVRelState *vacrel)
         * dead_items array.  This includes LP_DEAD line pointers that we
         * pruned ourselves, as well as existing LP_DEAD line pointers that
         * were pruned some time earlier.  Also considers freezing XIDs in the
-        * tuple headers of remaining items with storage.
+        * tuple headers of remaining items with storage. It also determines
+        * if truncating this block is safe.
         */
        lazy_scan_prune(vacrel, buf, blkno, page, &prunestate);
 
        Assert(!prunestate.all_visible || !prunestate.has_lpdead_items);
 
-       /* Remember the location of the last page with nonremovable tuples */
-       if (prunestate.hastup)
-           vacrel->nonempty_pages = blkno + 1;
-
        if (vacrel->nindexes == 0)
        {
            /*
@@ -1555,6 +1551,7 @@ lazy_scan_prune(LVRelState *vacrel,
                live_tuples,
                recently_dead_tuples;
    HeapPageFreeze pagefrz;
+   bool        hastup = false;
    int64       fpi_before = pgWalUsage.wal_fpi;
    OffsetNumber deadoffsets[MaxHeapTuplesPerPage];
    HeapTupleFreeze frozen[MaxHeapTuplesPerPage];
@@ -1593,7 +1590,6 @@ lazy_scan_prune(LVRelState *vacrel,
     * Now scan the page to collect LP_DEAD items and check for tuples
     * requiring freezing among remaining tuples with storage
     */
-   prunestate->hastup = false;
    prunestate->has_lpdead_items = false;
    prunestate->all_visible = true;
    prunestate->all_frozen = true;
@@ -1620,7 +1616,7 @@ lazy_scan_prune(LVRelState *vacrel,
        if (ItemIdIsRedirected(itemid))
        {
            /* page makes rel truncation unsafe */
-           prunestate->hastup = true;
+           hastup = true;
            continue;
        }
 
@@ -1750,7 +1746,7 @@ lazy_scan_prune(LVRelState *vacrel,
                break;
        }
 
-       prunestate->hastup = true;  /* page makes rel truncation unsafe */
+       hastup = true;          /* page makes rel truncation unsafe */
 
        /* Tuple with storage -- consider need to freeze */
        if (heap_prepare_freeze_tuple(htup, &vacrel->cutoffs, &pagefrz,
@@ -1918,6 +1914,10 @@ lazy_scan_prune(LVRelState *vacrel,
    vacrel->lpdead_items += lpdead_items;
    vacrel->live_tuples += live_tuples;
    vacrel->recently_dead_tuples += recently_dead_tuples;
+
+   /* Can't truncate this page */
+   if (hastup)
+       vacrel->nonempty_pages = blkno + 1;
 }
 
 /*
@@ -1935,7 +1935,6 @@ lazy_scan_prune(LVRelState *vacrel,
  * one or more tuples on the page.  We always return true for non-aggressive
  * callers.
  *
- * See lazy_scan_prune for an explanation of hastup return flag.
  * recordfreespace flag instructs caller on whether or not it should do
  * generic FSM processing for page.
  */
@@ -1944,7 +1943,6 @@ lazy_scan_noprune(LVRelState *vacrel,
                  Buffer buf,
                  BlockNumber blkno,
                  Page page,
-                 bool *hastup,
                  bool *recordfreespace)
 {
    OffsetNumber offnum,
@@ -1953,6 +1951,7 @@ lazy_scan_noprune(LVRelState *vacrel,
                live_tuples,
                recently_dead_tuples,
                missed_dead_tuples;
+   bool        hastup;
    HeapTupleHeader tupleheader;
    TransactionId NoFreezePageRelfrozenXid = vacrel->NewRelfrozenXid;
    MultiXactId NoFreezePageRelminMxid = vacrel->NewRelminMxid;
@@ -1960,7 +1959,7 @@ lazy_scan_noprune(LVRelState *vacrel,
 
    Assert(BufferGetBlockNumber(buf) == blkno);
 
-   *hastup = false;            /* for now */
+   hastup = false;             /* for now */
    *recordfreespace = false;   /* for now */
 
    lpdead_items = 0;
@@ -1984,7 +1983,7 @@ lazy_scan_noprune(LVRelState *vacrel,
 
        if (ItemIdIsRedirected(itemid))
        {
-           *hastup = true;
+           hastup = true;
            continue;
        }
 
@@ -1998,7 +1997,7 @@ lazy_scan_noprune(LVRelState *vacrel,
            continue;
        }
 
-       *hastup = true;         /* page prevents rel truncation */
+       hastup = true;          /* page prevents rel truncation */
        tupleheader = (HeapTupleHeader) PageGetItem(page, itemid);
        if (heap_tuple_should_freeze(tupleheader, &vacrel->cutoffs,
                                     &NoFreezePageRelfrozenXid,
@@ -2100,7 +2099,7 @@ lazy_scan_noprune(LVRelState *vacrel,
             * but it beats having to maintain specialized heap vacuuming code
             * forever, for vanishingly little benefit.)
             */
-           *hastup = true;
+           hastup = true;
            missed_dead_tuples += lpdead_items;
        }
 
@@ -2156,6 +2155,10 @@ lazy_scan_noprune(LVRelState *vacrel,
    if (missed_dead_tuples > 0)
        vacrel->missed_dead_pages++;
 
+   /* Can't truncate this page */
+   if (hastup)
+       vacrel->nonempty_pages = blkno + 1;
+
    /* Caller won't need to call lazy_scan_prune with same page */
    return true;
 }