Retain original physical order of tuples in redo of b-tree splits.

It makes no difference to the system, but minimizing the differences
between a master and standby makes debugging simpler.

diff --git a/src/backend/access/nbtree/nbtxlog.c b/src/backend/access/nbtree/nbtxlog.c
index 7e37a4ca58d068c73bc1941d295e88e79e2e27dd..ada2d6691f3a40a8b166c82954da87564fd53159 100644 (file)
--- a/src/backend/access/nbtree/nbtxlog.c
+++ b/src/backend/access/nbtree/nbtxlog.c
@@ -27,13 +27,6 @@
  * had been its upper part (pd_upper to pd_special).  We assume that the
  * tuples had been added to the page in item-number order, and therefore
  * the one with highest item number appears first (lowest on the page).
- *
- * NOTE: the way this routine is coded, the rebuilt page will have the items
- * in correct itemno sequence, but physically the opposite order from the
- * original, because we insert them in the opposite of itemno order.  This
- * does not matter in any current btree code, but it's something to keep an
- * eye on.     Is it worth changing just on general principles?  See also the
- * notes in btree_xlog_split().
  */
 static void
 _bt_restore_page(Page page, char *from, int len)
@@ -41,14 +34,35 @@ _bt_restore_page(Page page, char *from, int len)
        IndexTupleData itupdata;
        Size            itemsz;
        char       *end = from + len;
+       Item            items[MaxIndexTuplesPerPage];
+       uint16          itemsizes[MaxIndexTuplesPerPage];
+       int                     i;
+       int                     nitems;
 
-       for (; from < end;)
+       /*
+        * To get the items back in the original order, we add them to the page
+        * in reverse.  To figure out where one tuple ends and another begins,
+        * we have to scan them in forward order first.
+        */
+       i = 0;
+       while (from < end)
        {
                /* Need to copy tuple header due to alignment considerations */
                memcpy(&itupdata, from, sizeof(IndexTupleData));
                itemsz = IndexTupleDSize(itupdata);
                itemsz = MAXALIGN(itemsz);
-               if (PageAddItem(page, (Item) from, itemsz, FirstOffsetNumber,
+
+               items[i] = (Item) from;
+               itemsizes[i] = itemsz;
+               i++;
+
+               from += itemsz;
+       }
+       nitems = i;
+
+       for (i = nitems - 1; i >= 0; i--)
+       {
+               if (PageAddItem(page, items[i], itemsizes[i], nitems - i,
                                                false, false) == InvalidOffsetNumber)
                        elog(PANIC, "_bt_restore_page: cannot add item to page");
                from += itemsz;
@@ -332,10 +346,13 @@ btree_xlog_split(bool onleft, bool isroot,
                if (BufferIsValid(lbuf))
                {
                        /*
-                        * Note that this code ensures that the items remaining on the
-                        * left page are in the correct item number order, but it does not
-                        * reproduce the physical order they would have had.  Is this
-                        * worth changing?      See also _bt_restore_page().
+                        * To retain the same physical order of the tuples that they had,
+                        * we initialize a temporary empty page for the left page and add
+                        * all the items to that in item number order.  This mirrors how
+                        * _bt_split() works.  It's not strictly required to retain the
+                        * same physical order, as long as the items are in the correct
+                        * item number order, but it helps debugging.  See also
+                        * _bt_restore_page(), which does the same for the right page.
                         */
                        Page            lpage = (Page) BufferGetPage(lbuf);
                        BTPageOpaque lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
@@ -343,45 +360,52 @@ btree_xlog_split(bool onleft, bool isroot,
                        if (lsn > PageGetLSN(lpage))
                        {
                                OffsetNumber off;
-                               OffsetNumber maxoff = PageGetMaxOffsetNumber(lpage);
-                               OffsetNumber deletable[MaxOffsetNumber];
-                               int                     ndeletable = 0;
-
-                               /*
-                                * Remove the items from the left page that were copied to the
-                                * right page.  Also remove the old high key, if any. (We must
-                                * remove everything before trying to insert any items, else
-                                * we risk not having enough space.)
-                                */
-                               if (!P_RIGHTMOST(lopaque))
-                               {
-                                       deletable[ndeletable++] = P_HIKEY;
+                               Page            newlpage;
+                               OffsetNumber leftoff;
 
-                                       /*
-                                        * newitemoff is given to us relative to the original
-                                        * page's item numbering, so adjust it for this deletion.
-                                        */
-                                       newitemoff--;
+                               newlpage = PageGetTempPageCopySpecial(lpage);
+
+                               /* Set high key */
+                               leftoff = P_HIKEY;
+                               if (PageAddItem(newlpage, left_hikey, left_hikeysz,
+                                                               P_HIKEY, false, false) == InvalidOffsetNumber)
+                                       elog(PANIC, "failed to add high key to left page after split");
+                               leftoff = OffsetNumberNext(leftoff);
+
+                               for (off = P_FIRSTDATAKEY(lopaque); off < xlrec->firstright; off++)
+                               {
+                                       ItemId          itemid;
+                                       Size            itemsz;
+                                       Item            item;
+
+                                       /* add the new item if it was inserted on left page */
+                                       if (onleft && off == newitemoff)
+                                       {
+                                               if (PageAddItem(newlpage, newitem, newitemsz, leftoff,
+                                                                               false, false) == InvalidOffsetNumber)
+                                                       elog(ERROR, "failed to add new item to left page after split");
+                                               leftoff = OffsetNumberNext(leftoff);
+                                       }
+
+                                       itemid = PageGetItemId(lpage, off);
+                                       itemsz = ItemIdGetLength(itemid);
+                                       item = PageGetItem(lpage, itemid);
+                                       if (PageAddItem(newlpage, item, itemsz, leftoff,
+                                                                       false, false) == InvalidOffsetNumber)
+                                               elog(ERROR, "failed to add old item to left page after split");
+                                       leftoff = OffsetNumberNext(leftoff);
                                }
-                               for (off = xlrec->firstright; off <= maxoff; off++)
-                                       deletable[ndeletable++] = off;
-                               if (ndeletable > 0)
-                                       PageIndexMultiDelete(lpage, deletable, ndeletable);
-
-                               /*
-                                * Add the new item if it was inserted on left page.
-                                */
-                               if (onleft)
+
+                               /* cope with possibility that newitem goes at the end */
+                               if (onleft && off == newitemoff)
                                {
-                                       if (PageAddItem(lpage, newitem, newitemsz, newitemoff,
+                                       if (PageAddItem(newlpage, newitem, newitemsz, leftoff,
                                                                        false, false) == InvalidOffsetNumber)
-                                               elog(PANIC, "failed to add new item to left page after split");
+                                               elog(ERROR, "failed to add new item to left page after split");
+                                       leftoff = OffsetNumberNext(leftoff);
                                }
 
-                               /* Set high key */
-                               if (PageAddItem(lpage, left_hikey, left_hikeysz,
-                                                               P_HIKEY, false, false) == InvalidOffsetNumber)
-                                       elog(PANIC, "failed to add high key to left page after split");
+                               PageRestoreTempPage(newlpage, lpage);
 
                                /* Fix opaque fields */
                                lopaque->btpo_flags = BTP_INCOMPLETE_SPLIT;