Further optimize GIN multi-key searches.

When skipping over some items in a posting tree, re-find the new location
by descending the tree from root, rather than walking the right links.
This can save a lot of I/O.

Heavily modified from Alexander Korotkov's fast scan patch.

diff --git a/src/backend/access/gin/gindatapage.c b/src/backend/access/gin/gindatapage.c
index 9a0b8ab1f214258ece93695f96ec04a441cc3018..c6230f3bc5a433a408a7290ba72900a9f5aa354b 100644 (file)
--- a/src/backend/access/gin/gindatapage.c
+++ b/src/backend/access/gin/gindatapage.c
@@ -1639,16 +1639,15 @@ ginInsertItemPointers(Relation index, BlockNumber rootBlkno,
  * Starts a new scan on a posting tree.
  */
 GinBtreeStack *
-ginScanBeginPostingTree(Relation index, BlockNumber rootBlkno)
+ginScanBeginPostingTree(GinBtree btree, Relation index, BlockNumber rootBlkno)
 {
-   GinBtreeData btree;
    GinBtreeStack *stack;
 
-   ginPrepareDataScan(&btree, index, rootBlkno);
+   ginPrepareDataScan(btree, index, rootBlkno);
 
-   btree.fullScan = TRUE;
+   btree->fullScan = TRUE;
 
-   stack = ginFindLeafPage(&btree, TRUE);
+   stack = ginFindLeafPage(btree, TRUE);
 
    return stack;
 }

diff --git a/src/backend/access/gin/ginget.c b/src/backend/access/gin/ginget.c
index 49e47c6859c57e44932aa87e1489f0e8e715f9cf..a45d72212e9436b27e418dec81a9a0380d1bf637 100644 (file)
--- a/src/backend/access/gin/ginget.c
+++ b/src/backend/access/gin/ginget.c
@@ -99,12 +99,13 @@ static void
 scanPostingTree(Relation index, GinScanEntry scanEntry,
                BlockNumber rootPostingTree)
 {
+   GinBtreeData btree;
    GinBtreeStack *stack;
    Buffer      buffer;
    Page        page;
 
    /* Descend to the leftmost leaf page */
-   stack = ginScanBeginPostingTree(index, rootPostingTree);
+   stack = ginScanBeginPostingTree(&btree, index, rootPostingTree);
    buffer = stack->buffer;
    IncrBufferRefCount(buffer); /* prevent unpin in freeGinBtreeStack */
 
@@ -412,7 +413,8 @@ restartScanEntry:
            LockBuffer(stackEntry->buffer, GIN_UNLOCK);
            needUnlock = FALSE;
 
-           stack = ginScanBeginPostingTree(ginstate->index, rootPostingTree);
+           stack = ginScanBeginPostingTree(&entry->btree, ginstate->index,
+                                           rootPostingTree);
            entry->buffer = stack->buffer;
 
            /*
@@ -506,8 +508,60 @@ entryLoadMoreItems(GinState *ginstate, GinScanEntry entry, ItemPointerData advan
 {
    Page        page;
    int         i;
+   bool        stepright;
+
+   if (!BufferIsValid(entry->buffer))
+   {
+       entry->isFinished = true;
+       return;
+   }
+
+   /*
+    * We have two strategies for finding the correct page: step right from
+    * the current page, or descend the tree again from the root. If
+    * advancePast equals the current item, the next matching item should be
+    * on the next page, so we step right. Otherwise, descend from root.
+    */
+   if (ginCompareItemPointers(&entry->curItem, &advancePast) == 0)
+   {
+       stepright = true;
+       LockBuffer(entry->buffer, GIN_SHARE);
+   }
+   else
+   {
+       GinBtreeStack *stack;
+
+       ReleaseBuffer(entry->buffer);
+
+       /*
+        * Set the search key, and find the correct leaf page.
+        */
+       if (ItemPointerIsLossyPage(&advancePast))
+       {
+           ItemPointerSet(&entry->btree.itemptr,
+                          GinItemPointerGetBlockNumber(&advancePast) + 1,
+                          FirstOffsetNumber);
+       }
+       else
+       {
+           entry->btree.itemptr = advancePast;
+           entry->btree.itemptr.ip_posid++;
+       }
+       entry->btree.fullScan = false;
+       stack = ginFindLeafPage(&entry->btree, true);
+
+       /* we don't need the stack, just the buffer. */
+       entry->buffer = stack->buffer;
+       IncrBufferRefCount(entry->buffer);
+       freeGinBtreeStack(stack);
+       stepright = false;
+   }
+
+   elog(DEBUG2, "entryLoadMoreItems, %u/%u, skip: %d",
+        GinItemPointerGetBlockNumber(&advancePast),
+        GinItemPointerGetOffsetNumber(&advancePast),
+        !stepright);
 
-   LockBuffer(entry->buffer, GIN_SHARE);
    page = BufferGetPage(entry->buffer);
    for (;;)
    {
@@ -519,30 +573,34 @@ entryLoadMoreItems(GinState *ginstate, GinScanEntry entry, ItemPointerData advan
            entry->nlist = 0;
        }
 
-       /*
-        * We've processed all the entries on this page. If it was the last
-        * page in the tree, we're done.
-        */
-       if (GinPageRightMost(page))
+       if (stepright)
        {
-           UnlockReleaseBuffer(entry->buffer);
-           entry->buffer = InvalidBuffer;
-           entry->isFinished = TRUE;
-           return;
+           /*
+            * We've processed all the entries on this page. If it was the last
+            * page in the tree, we're done.
+            */
+           if (GinPageRightMost(page))
+           {
+               UnlockReleaseBuffer(entry->buffer);
+               entry->buffer = InvalidBuffer;
+               entry->isFinished = TRUE;
+               return;
+           }
+
+           /*
+            * Step to next page, following the right link. then find the first
+            * ItemPointer greater than advancePast.
+            */
+           entry->buffer = ginStepRight(entry->buffer,
+                                        ginstate->index,
+                                        GIN_SHARE);
+           page = BufferGetPage(entry->buffer);
        }
+       stepright = true;
 
        if (GinPageGetOpaque(page)->flags & GIN_DELETED)
            continue;       /* page was deleted by concurrent vacuum */
 
-       /*
-        * Step to next page, following the right link. then find the first
-        * ItemPointer greater than advancePast.
-        */
-       entry->buffer = ginStepRight(entry->buffer,
-                                    ginstate->index,
-                                    GIN_SHARE);
-       page = BufferGetPage(entry->buffer);
-
        /*
         * The first item > advancePast might not be on this page, but
         * somewhere to the right, if the page was split, or a non-match from
@@ -566,8 +624,16 @@ entryLoadMoreItems(GinState *ginstate, GinScanEntry entry, ItemPointerData advan
        {
            if (ginCompareItemPointers(&advancePast, &entry->list[i]) < 0)
            {
-               LockBuffer(entry->buffer, GIN_UNLOCK);
                entry->offset = i;
+
+               if (GinPageRightMost(page))
+               {
+                   /* after processing the copied items, we're done. */
+                   UnlockReleaseBuffer(entry->buffer);
+                   entry->buffer = InvalidBuffer;
+               }
+               else
+                   LockBuffer(entry->buffer, GIN_UNLOCK);
                return;
            }
        }
@@ -677,7 +743,10 @@ entryGetItem(GinState *ginstate, GinScanEntry entry,
    }
    else if (!BufferIsValid(entry->buffer))
    {
-       /* A posting list from an entry tuple  */
+       /*
+        * A posting list from an entry tuple, or the last page of a posting
+        * tree.
+        */
        do
        {
            if (entry->offset >= entry->nlist)

diff --git a/src/include/access/gin_private.h b/src/include/access/gin_private.h
index ea9ae31acc0ea57b42740585f78de2fd893eda42..bb0ab317cbcf6859eccdb36807f4a55a818b5d64 100644 (file)
--- a/src/include/access/gin_private.h
+++ b/src/include/access/gin_private.h
@@ -702,7 +702,7 @@ extern void GinPageDeletePostingItem(Page page, OffsetNumber offset);
 extern void ginInsertItemPointers(Relation index, BlockNumber rootBlkno,
                      ItemPointerData *items, uint32 nitem,
                      GinStatsData *buildStats);
-extern GinBtreeStack *ginScanBeginPostingTree(Relation index, BlockNumber rootBlkno);
+extern GinBtreeStack *ginScanBeginPostingTree(GinBtree btree, Relation index, BlockNumber rootBlkno);
 extern void ginDataFillRoot(GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage);
 extern void ginPrepareDataScan(GinBtree btree, Relation index, BlockNumber rootBlkno);
 
@@ -802,6 +802,7 @@ typedef struct GinScanEntryData
    bool        isFinished;
    bool        reduceResult;
    uint32      predictNumberResult;
+   GinBtreeData btree;
 }  GinScanEntryData;
 
 typedef struct GinScanOpaqueData