nbtree: Simplify _bt_first parallel scan handling.

This new structure relieves _bt_first from having separate calls to
_bt_start_array_keys for the serial case and parallel case.  This saves
code, and seems clearer.

Follow-up to work from commits 4e6e375b and b5ee4e52.

Author: Peter Geoghegan <pg@bowt.ie>
Reviewed-By: Matthias van de Meent <boekewurm+postgres@gmail.com>
Discussion: https://postgr.es/m/CAH2-Wz=XjUZjBjHJdhTvuH5MwoJObWGoM2RG2LyFg5WUdWyk=A@mail.gmail.com

diff --git a/src/backend/access/nbtree/nbtsearch.c b/src/backend/access/nbtree/nbtsearch.c
index ad7feccc180c0c043c293e1cac2611690f4d64a3..8f559629cd5af5ad7c76c7a41e9de9c62574bddd 100644 (file)
--- a/src/backend/access/nbtree/nbtsearch.c
+++ b/src/backend/access/nbtree/nbtsearch.c
@@ -890,6 +890,8 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
    ScanKeyData notnullkeys[INDEX_MAX_KEYS];
    int         keysz = 0;
    StrategyNumber strat_total;
+   BlockNumber blkno = InvalidBlockNumber,
+               lastcurrblkno;
 
    Assert(!BTScanPosIsValid(so->currPos));
 
@@ -905,64 +907,42 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
     */
    if (!so->qual_ok)
    {
+       Assert(!so->needPrimScan);
        _bt_parallel_done(scan);
        return false;
    }
 
    /*
-    * For parallel scans, get the starting page from shared state. If the
-    * scan has not started, proceed to find out first leaf page in the usual
-    * way while keeping other participating processes waiting.  If the scan
-    * has already begun, use the page number from the shared structure.
-    *
-    * When a parallel scan has another primitive index scan scheduled, a
-    * parallel worker will seize the scan for that purpose now.  This is
-    * similar to the case where the top-level scan hasn't started.
+    * If this is a parallel scan, we must seize the scan.  _bt_readfirstpage
+    * will likely release the parallel scan later on.
     */
-   if (scan->parallel_scan != NULL)
-   {
-       BlockNumber blkno,
-                   lastcurrblkno;
+   if (scan->parallel_scan != NULL &&
+       !_bt_parallel_seize(scan, &blkno, &lastcurrblkno, true))
+       return false;
 
-       if (!_bt_parallel_seize(scan, &blkno, &lastcurrblkno, true))
-           return false;
+   /*
+    * Initialize the scan's arrays (if any) for the current scan direction
+    * (except when they were already set to later values as part of
+    * scheduling the primitive index scan that is now underway)
+    */
+   if (so->numArrayKeys && !so->needPrimScan)
+       _bt_start_array_keys(scan, dir);
 
+   if (blkno != InvalidBlockNumber)
+   {
        /*
-        * Successfully seized the scan, which _bt_readfirstpage or possibly
-        * _bt_readnextpage will release (unless the scan ends right away, in
-        * which case we'll call _bt_parallel_done directly).
-        *
-        * Initialize arrays (when _bt_parallel_seize didn't already set up
-        * the next primitive index scan).
+        * We anticipated calling _bt_search, but another worker bet us to it.
+        * _bt_readnextpage releases the scan for us (not _bt_readfirstpage).
         */
-       if (so->numArrayKeys && !so->needPrimScan)
-           _bt_start_array_keys(scan, dir);
-
+       Assert(scan->parallel_scan != NULL);
+       Assert(!so->needPrimScan);
        Assert(blkno != P_NONE);
-       if (blkno != InvalidBlockNumber)
-       {
-           Assert(!so->needPrimScan);
 
-           /*
-            * We anticipated starting another primitive scan, but some other
-            * worker bet us to it
-            */
-           if (!_bt_readnextpage(scan, blkno, lastcurrblkno, dir, true))
-               return false;
+       if (!_bt_readnextpage(scan, blkno, lastcurrblkno, dir, true))
+           return false;
 
-           _bt_returnitem(scan, so);
-           return true;
-       }
-   }
-   else if (so->numArrayKeys && !so->needPrimScan)
-   {
-       /*
-        * First _bt_first call (for current btrescan) without parallelism.
-        *
-        * Initialize arrays, and the corresponding scan keys that were just
-        * output by _bt_preprocess_keys.
-        */
-       _bt_start_array_keys(scan, dir);
+       _bt_returnitem(scan, so);
+       return true;
    }
 
    /*
@@ -1090,7 +1070,12 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
                    break;
                startKeys[keysz++] = chosen;
 
-               /* Quit if we have stored a > or < key */
+               /*
+                * We can only consider adding more boundary keys when the one
+                * that we just chose to add uses either the = or >= strategy
+                * (during backwards scans we can only do so when the key that
+                * we just added to startKeys[] uses the = or <= strategy)
+                */
                strat_total = chosen->sk_strategy;
                if (strat_total == BTGreaterStrategyNumber ||
                    strat_total == BTLessStrategyNumber)
@@ -1190,6 +1175,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
            Assert(subkey->sk_flags & SK_ROW_MEMBER);
            if (subkey->sk_flags & SK_ISNULL)
            {
+               Assert(!so->needPrimScan);
                _bt_parallel_done(scan);
                return false;
            }
@@ -1408,6 +1394,7 @@ _bt_first(IndexScanDesc scan, ScanDirection dir)
 
        if (!BufferIsValid(so->currPos.buf))
        {
+           Assert(!so->needPrimScan);
            _bt_parallel_done(scan);
            return false;
        }
@@ -2553,6 +2540,7 @@ _bt_endpoint(IndexScanDesc scan, ScanDirection dir)
    OffsetNumber start;
 
    Assert(!BTScanPosIsValid(so->currPos));
+   Assert(!so->needPrimScan);
 
    /*
     * Scan down to the leftmost or rightmost leaf page.  This is a simplified