Index-only-scans, indexam API changes

At the moment, amgettuple only returns pointers to heap tuples. There is
no way to return data from the index tuples. That needs to be changed to
support index-only scans.

I propose that we split index_getnext into two steps: fetching the next
match from the index (index_next()), and fetching the corresponding heap
tuple (index_fetch()). Patch attached. There is still a shorthand
index_getnext() that is compatible with the old function, but it now
just calls index_next()+index_fetch().

The new index_fetch() function can only fetch one match from a HOT
chain. That greatly simplifies the code in indexam.c. The only caller
needing to fetch more than one tuple from a HOT chain (= using
SnapshotAny) is CLUSTER, so I moved the HOT-chain following logic into
cluster.c, with small changes to heap_hot_search_buffer().

--
  Heikki Linnakangas
  EnterpriseDB   http://www.enterprisedb.com
*** a/src/backend/access/heap/heapam.c
--- b/src/backend/access/heap/heapam.c
***************
*** 1490,1497 **** heap_fetch(Relation relation,
   * On entry, *tid is the TID of a tuple (either a simple tuple, or the root
   * of a HOT chain), and buffer is the buffer holding this tuple.  We search
   * for the first chain member satisfying the given snapshot.  If one is
!  * found, we update *tid to reference that tuple's offset number, and
!  * return TRUE.  If no match, return FALSE without modifying *tid.
   *
   * If all_dead is not NULL, we check non-visible tuples to see if they are
   * globally dead; *all_dead is set TRUE if all members of the HOT chain
--- 1490,1503 ----
   * On entry, *tid is the TID of a tuple (either a simple tuple, or the root
   * of a HOT chain), and buffer is the buffer holding this tuple.  We search
   * for the first chain member satisfying the given snapshot.  If one is
!  * found, we update *tid and *heapTuple to reference that tuple, and
!  * return TRUE.  If no match, return FALSE without modifying *tid (*heapTuple
!  * is undefined in that case).
!  *
!  * To fetch the next matching tuple in the chain, call again with 'firstCall'
!  * set to FALSE and *tid still pointing to the tuple returned by previous call.
!  * (normally only one tuple in a chain can be visible at a time, but that does
!  * not hold for special snapshots like SnapshotAny)
   *
   * If all_dead is not NULL, we check non-visible tuples to see if they are
   * globally dead; *all_dead is set TRUE if all members of the HOT chain
***************
*** 1503,1529 **** heap_fetch(Relation relation,
   */
  bool
  heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
!                        bool *all_dead)
  {
      Page        dp = (Page) BufferGetPage(buffer);
      TransactionId prev_xmax = InvalidTransactionId;
      OffsetNumber offnum;
      bool        at_chain_start;

!     if (all_dead)
          *all_dead = true;

      Assert(TransactionIdIsValid(RecentGlobalXmin));

      Assert(ItemPointerGetBlockNumber(tid) == BufferGetBlockNumber(buffer));
      offnum = ItemPointerGetOffsetNumber(tid);
!     at_chain_start = true;

      /* Scan through possible multiple members of HOT-chain */
      for (;;)
      {
          ItemId        lp;
-         HeapTupleData heapTuple;

          /* check for bogus TID */
          if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
--- 1509,1537 ----
   */
  bool
  heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
!                        HeapTuple heapTuple, bool *all_dead, bool firstCall)
  {
      Page        dp = (Page) BufferGetPage(buffer);
      TransactionId prev_xmax = InvalidTransactionId;
      OffsetNumber offnum;
      bool        at_chain_start;
+     bool        skip;

!     if (all_dead && firstCall)
          *all_dead = true;

      Assert(TransactionIdIsValid(RecentGlobalXmin));

      Assert(ItemPointerGetBlockNumber(tid) == BufferGetBlockNumber(buffer));
      offnum = ItemPointerGetOffsetNumber(tid);
!
!     at_chain_start = firstCall;
!     skip = !firstCall;

      /* Scan through possible multiple members of HOT-chain */
      for (;;)
      {
          ItemId        lp;

          /* check for bogus TID */
          if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
***************
*** 1546,1558 **** heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
              break;
          }

!         heapTuple.t_data = (HeapTupleHeader) PageGetItem(dp, lp);
!         heapTuple.t_len = ItemIdGetLength(lp);

          /*
           * Shouldn't see a HEAP_ONLY tuple at chain start.
           */
!         if (at_chain_start && HeapTupleIsHeapOnly(&heapTuple))
              break;

          /*
--- 1554,1566 ----
              break;
          }

!         heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp);
!         heapTuple->t_len = ItemIdGetLength(lp);

          /*
           * Shouldn't see a HEAP_ONLY tuple at chain start.
           */
!         if (at_chain_start && HeapTupleIsHeapOnly(heapTuple))
              break;

          /*
***************
*** 1561,1577 **** heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
           */
          if (TransactionIdIsValid(prev_xmax) &&
              !TransactionIdEquals(prev_xmax,
!                                  HeapTupleHeaderGetXmin(heapTuple.t_data)))
              break;

          /* If it's visible per the snapshot, we must return it */
!         if (HeapTupleSatisfiesVisibility(&heapTuple, snapshot, buffer))
          {
              ItemPointerSetOffsetNumber(tid, offnum);
              if (all_dead)
                  *all_dead = false;
              return true;
          }

          /*
           * If we can't see it, maybe no one else can either.  At caller
--- 1569,1586 ----
           */
          if (TransactionIdIsValid(prev_xmax) &&
              !TransactionIdEquals(prev_xmax,
!                                  HeapTupleHeaderGetXmin(heapTuple->t_data)))
              break;

          /* If it's visible per the snapshot, we must return it */
!         if (!skip && HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer))
          {
              ItemPointerSetOffsetNumber(tid, offnum);
              if (all_dead)
                  *all_dead = false;
              return true;
          }
+         skip = false;

          /*
           * If we can't see it, maybe no one else can either.  At caller
***************
*** 1579,1585 **** heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
           * transactions.
           */
          if (all_dead && *all_dead &&
!             HeapTupleSatisfiesVacuum(heapTuple.t_data, RecentGlobalXmin,
                                       buffer) != HEAPTUPLE_DEAD)
              *all_dead = false;

--- 1588,1594 ----
           * transactions.
           */
          if (all_dead && *all_dead &&
!             HeapTupleSatisfiesVacuum(heapTuple->t_data, RecentGlobalXmin,
                                       buffer) != HEAPTUPLE_DEAD)
              *all_dead = false;

***************
*** 1587,1599 **** heap_hot_search_buffer(ItemPointer tid, Buffer buffer, Snapshot snapshot,
           * Check to see if HOT chain continues past this tuple; if so fetch
           * the next offnum and loop around.
           */
!         if (HeapTupleIsHotUpdated(&heapTuple))
          {
!             Assert(ItemPointerGetBlockNumber(&heapTuple.t_data->t_ctid) ==
                     ItemPointerGetBlockNumber(tid));
!             offnum = ItemPointerGetOffsetNumber(&heapTuple.t_data->t_ctid);
              at_chain_start = false;
!             prev_xmax = HeapTupleHeaderGetXmax(heapTuple.t_data);
          }
          else
              break;                /* end of chain */
--- 1596,1608 ----
           * Check to see if HOT chain continues past this tuple; if so fetch
           * the next offnum and loop around.
           */
!         if (HeapTupleIsHotUpdated(heapTuple))
          {
!             Assert(ItemPointerGetBlockNumber(&heapTuple->t_data->t_ctid) ==
                     ItemPointerGetBlockNumber(tid));
!             offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
              at_chain_start = false;
!             prev_xmax = HeapTupleHeaderGetXmax(heapTuple->t_data);
          }
          else
              break;                /* end of chain */
***************
*** 1615,1624 **** heap_hot_search(ItemPointer tid, Relation relation, Snapshot snapshot,
  {
      bool        result;
      Buffer        buffer;

      buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
      LockBuffer(buffer, BUFFER_LOCK_SHARE);
!     result = heap_hot_search_buffer(tid, buffer, snapshot, all_dead);
      LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
      ReleaseBuffer(buffer);
      return result;
--- 1624,1635 ----
  {
      bool        result;
      Buffer        buffer;
+     HeapTupleData heapTuple;

      buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
      LockBuffer(buffer, BUFFER_LOCK_SHARE);
!     result = heap_hot_search_buffer(tid, buffer, snapshot, &heapTuple,
!                                     all_dead, true);
      LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
      ReleaseBuffer(buffer);
      return result;
*** a/src/backend/access/index/genam.c
--- b/src/backend/access/index/genam.c
***************
*** 97,105 **** RelationGetIndexScan(Relation indexRelation,
      ItemPointerSetInvalid(&scan->xs_ctup.t_self);
      scan->xs_ctup.t_data = NULL;
      scan->xs_cbuf = InvalidBuffer;
-     scan->xs_hot_dead = false;
-     scan->xs_next_hot = InvalidOffsetNumber;
-     scan->xs_prev_xmax = InvalidTransactionId;

      /*
       * Let the AM fill in the key and any opaque data it wants.
--- 97,102 ----
*** a/src/backend/access/index/indexam.c
--- b/src/backend/access/index/indexam.c
***************
*** 20,26 ****
   *        index_insert    - insert an index tuple into a relation
   *        index_markpos    - mark a scan position
   *        index_restrpos    - restore a scan position
!  *        index_getnext    - get the next tuple from a scan
   *        index_getbitmap - get all tuples from a scan
   *        index_bulk_delete    - bulk deletion of index tuples
   *        index_vacuum_cleanup    - post-deletion cleanup of an index
--- 20,27 ----
   *        index_insert    - insert an index tuple into a relation
   *        index_markpos    - mark a scan position
   *        index_restrpos    - restore a scan position
!  *        index_next        - advance index scan to next match
!  *        index_fetch        - fetch heap tuple for current index scan position
   *        index_getbitmap - get all tuples from a scan
   *        index_bulk_delete    - bulk deletion of index tuples
   *        index_vacuum_cleanup    - post-deletion cleanup of an index
***************
*** 310,317 **** index_rescan(IndexScanDesc scan, ScanKey key)
          scan->xs_cbuf = InvalidBuffer;
      }

-     scan->xs_next_hot = InvalidOffsetNumber;
-
      scan->kill_prior_tuple = false;        /* for safety */

      FunctionCall2(procedure,
--- 311,316 ----
***************
*** 389,420 **** index_restrpos(IndexScanDesc scan)
      SCAN_CHECKS;
      GET_SCAN_PROCEDURE(amrestrpos);

-     scan->xs_next_hot = InvalidOffsetNumber;
-
      scan->kill_prior_tuple = false;        /* for safety */

      FunctionCall1(procedure, PointerGetDatum(scan));
  }

  /* ----------------
!  *        index_getnext - get the next heap tuple from a scan
   *
!  * The result is the next heap tuple satisfying the scan keys and the
!  * snapshot, or NULL if no more matching tuples exist.    On success,
!  * the buffer containing the heap tuple is pinned (the pin will be dropped
!  * at the next index_getnext or index_endscan).
   *
   * Note: caller must check scan->xs_recheck, and perform rechecking of the
   * scan keys if required.  We do not do that here because we don't have
   * enough information to do it efficiently in the general case.
   * ----------------
   */
! HeapTuple
! index_getnext(IndexScanDesc scan, ScanDirection direction)
  {
-     HeapTuple    heapTuple = &scan->xs_ctup;
-     ItemPointer tid = &heapTuple->t_self;
      FmgrInfo   *procedure;

      SCAN_CHECKS;
      GET_SCAN_PROCEDURE(amgettuple);
--- 388,415 ----
      SCAN_CHECKS;
      GET_SCAN_PROCEDURE(amrestrpos);

      scan->kill_prior_tuple = false;        /* for safety */

      FunctionCall1(procedure, PointerGetDatum(scan));
  }

  /* ----------------
!  *        index_next - get the next index tuple from a scan
   *
!  * Advances to the next index tuple satisfying the scan keys, returning TRUE
!  * if there was one, FALSE otherwise. The heap TID pointer of the next match
!  * is stored in scan->xs_ctup.self.
   *
   * Note: caller must check scan->xs_recheck, and perform rechecking of the
   * scan keys if required.  We do not do that here because we don't have
   * enough information to do it efficiently in the general case.
   * ----------------
   */
! bool
! index_next(IndexScanDesc scan, ScanDirection direction)
  {
      FmgrInfo   *procedure;
+     bool         found;

      SCAN_CHECKS;
      GET_SCAN_PROCEDURE(amgettuple);
***************
*** 422,641 **** index_getnext(IndexScanDesc scan, ScanDirection direction)
      Assert(TransactionIdIsValid(RecentGlobalXmin));

      /*
!      * We always reset xs_hot_dead; if we are here then either we are just
!      * starting the scan, or we previously returned a visible tuple, and in
!      * either case it's inappropriate to kill the prior index entry.
       */
!     scan->xs_hot_dead = false;

!     for (;;)
!     {
!         OffsetNumber offnum;
!         bool        at_chain_start;
!         Page        dp;

!         if (scan->xs_next_hot != InvalidOffsetNumber)
!         {
!             /*
!              * We are resuming scan of a HOT chain after having returned an
!              * earlier member.    Must still hold pin on current heap page.
!              */
!             Assert(BufferIsValid(scan->xs_cbuf));
!             Assert(ItemPointerGetBlockNumber(tid) ==
!                    BufferGetBlockNumber(scan->xs_cbuf));
!             Assert(TransactionIdIsValid(scan->xs_prev_xmax));
!             offnum = scan->xs_next_hot;
!             at_chain_start = false;
!             scan->xs_next_hot = InvalidOffsetNumber;
!         }
!         else
          {
!             bool        found;
!             Buffer        prev_buf;
!
!             /*
!              * If we scanned a whole HOT chain and found only dead tuples,
!              * tell index AM to kill its entry for that TID.
!              */
!             scan->kill_prior_tuple = scan->xs_hot_dead;
!
!             /*
!              * The AM's gettuple proc finds the next index entry matching the
!              * scan keys, and puts the TID in xs_ctup.t_self (ie, *tid). It
!              * should also set scan->xs_recheck, though we pay no attention to
!              * that here.
!              */
!             found = DatumGetBool(FunctionCall2(procedure,
!                                                PointerGetDatum(scan),
!                                                Int32GetDatum(direction)));
!
!             /* Reset kill flag immediately for safety */
!             scan->kill_prior_tuple = false;
!
!             /* If we're out of index entries, break out of outer loop */
!             if (!found)
!                 break;
!
!             pgstat_count_index_tuples(scan->indexRelation, 1);
!
!             /* Switch to correct buffer if we don't have it already */
!             prev_buf = scan->xs_cbuf;
!             scan->xs_cbuf = ReleaseAndReadBuffer(scan->xs_cbuf,
!                                                  scan->heapRelation,
!                                              ItemPointerGetBlockNumber(tid));
!
!             /*
!              * Prune page, but only if we weren't already on this page
!              */
!             if (prev_buf != scan->xs_cbuf)
!                 heap_page_prune_opt(scan->heapRelation, scan->xs_cbuf,
!                                     RecentGlobalXmin);
!
!             /* Prepare to scan HOT chain starting at index-referenced offnum */
!             offnum = ItemPointerGetOffsetNumber(tid);
!             at_chain_start = true;
!
!             /* We don't know what the first tuple's xmin should be */
!             scan->xs_prev_xmax = InvalidTransactionId;
!
!             /* Initialize flag to detect if all entries are dead */
!             scan->xs_hot_dead = true;
          }

!         /* Obtain share-lock on the buffer so we can examine visibility */
!         LockBuffer(scan->xs_cbuf, BUFFER_LOCK_SHARE);

!         dp = (Page) BufferGetPage(scan->xs_cbuf);

-         /* Scan through possible multiple members of HOT-chain */
-         for (;;)
-         {
-             ItemId        lp;
-             ItemPointer ctid;
-
-             /* check for bogus TID */
-             if (offnum < FirstOffsetNumber ||
-                 offnum > PageGetMaxOffsetNumber(dp))
-                 break;
-
-             lp = PageGetItemId(dp, offnum);
-
-             /* check for unused, dead, or redirected items */
-             if (!ItemIdIsNormal(lp))
-             {
-                 /* We should only see a redirect at start of chain */
-                 if (ItemIdIsRedirected(lp) && at_chain_start)
-                 {
-                     /* Follow the redirect */
-                     offnum = ItemIdGetRedirect(lp);
-                     at_chain_start = false;
-                     continue;
-                 }
-                 /* else must be end of chain */
-                 break;
-             }
-
-             /*
-              * We must initialize all of *heapTuple (ie, scan->xs_ctup) since
-              * it is returned to the executor on success.
-              */
-             heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp);
-             heapTuple->t_len = ItemIdGetLength(lp);
-             ItemPointerSetOffsetNumber(tid, offnum);
-             heapTuple->t_tableOid = RelationGetRelid(scan->heapRelation);
-             ctid = &heapTuple->t_data->t_ctid;
-
-             /*
-              * Shouldn't see a HEAP_ONLY tuple at chain start.  (This test
-              * should be unnecessary, since the chain root can't be removed
-              * while we have pin on the index entry, but let's make it
-              * anyway.)
-              */
-             if (at_chain_start && HeapTupleIsHeapOnly(heapTuple))
-                 break;
-
-             /*
-              * The xmin should match the previous xmax value, else chain is
-              * broken.    (Note: this test is not optional because it protects
-              * us against the case where the prior chain member's xmax aborted
-              * since we looked at it.)
-              */
-             if (TransactionIdIsValid(scan->xs_prev_xmax) &&
-                 !TransactionIdEquals(scan->xs_prev_xmax,
-                                   HeapTupleHeaderGetXmin(heapTuple->t_data)))
-                 break;
-
-             /* If it's visible per the snapshot, we must return it */
-             if (HeapTupleSatisfiesVisibility(heapTuple, scan->xs_snapshot,
-                                              scan->xs_cbuf))
-             {
-                 /*
-                  * If the snapshot is MVCC, we know that it could accept at
-                  * most one member of the HOT chain, so we can skip examining
-                  * any more members.  Otherwise, check for continuation of the
-                  * HOT-chain, and set state for next time.
-                  */
-                 if (IsMVCCSnapshot(scan->xs_snapshot))
-                     scan->xs_next_hot = InvalidOffsetNumber;
-                 else if (HeapTupleIsHotUpdated(heapTuple))
-                 {
-                     Assert(ItemPointerGetBlockNumber(ctid) ==
-                            ItemPointerGetBlockNumber(tid));
-                     scan->xs_next_hot = ItemPointerGetOffsetNumber(ctid);
-                     scan->xs_prev_xmax = HeapTupleHeaderGetXmax(heapTuple->t_data);
-                 }
-                 else
-                     scan->xs_next_hot = InvalidOffsetNumber;
-
-                 LockBuffer(scan->xs_cbuf, BUFFER_LOCK_UNLOCK);
-
-                 pgstat_count_heap_fetch(scan->indexRelation);
-
-                 return heapTuple;
-             }
-
-             /*
-              * If we can't see it, maybe no one else can either.  Check to see
-              * if the tuple is dead to all transactions.  If we find that all
-              * the tuples in the HOT chain are dead, we'll signal the index AM
-              * to not return that TID on future indexscans.
-              */
-             if (scan->xs_hot_dead &&
-                 HeapTupleSatisfiesVacuum(heapTuple->t_data, RecentGlobalXmin,
-                                          scan->xs_cbuf) != HEAPTUPLE_DEAD)
-                 scan->xs_hot_dead = false;
-
-             /*
-              * Check to see if HOT chain continues past this tuple; if so
-              * fetch the next offnum (we don't bother storing it into
-              * xs_next_hot, but must store xs_prev_xmax), and loop around.
-              */
-             if (HeapTupleIsHotUpdated(heapTuple))
-             {
-                 Assert(ItemPointerGetBlockNumber(ctid) ==
-                        ItemPointerGetBlockNumber(tid));
-                 offnum = ItemPointerGetOffsetNumber(ctid);
-                 at_chain_start = false;
-                 scan->xs_prev_xmax = HeapTupleHeaderGetXmax(heapTuple->t_data);
-             }
-             else
-                 break;            /* end of chain */
-         }                        /* loop over a single HOT chain */
-
-         LockBuffer(scan->xs_cbuf, BUFFER_LOCK_UNLOCK);
-
-         /* Loop around to ask index AM for another TID */
-         scan->xs_next_hot = InvalidOffsetNumber;
-     }

!     /* Release any held pin on a heap page */
!     if (BufferIsValid(scan->xs_cbuf))
      {
!         ReleaseBuffer(scan->xs_cbuf);
!         scan->xs_cbuf = InvalidBuffer;
      }

!     return NULL;                /* failure exit */
  }

  /* ----------------
--- 417,541 ----
      Assert(TransactionIdIsValid(RecentGlobalXmin));

      /*
!      * The AM's gettuple proc finds the next index entry matching the scan
!      * keys, and puts the TID in xs_ctup.t_self. It should also set
!      * scan->xs_recheck, though we pay no attention to that here.
       */
!     found = DatumGetBool(FunctionCall2(procedure,
!                                        PointerGetDatum(scan),
!                                        Int32GetDatum(direction)));

!     /* Reset kill flag immediately for safety */
!     scan->kill_prior_tuple = false;

!     /* If we're out of index entries, release any held pin on a heap page */
!     if (!found)
!     {
!         if (BufferIsValid(scan->xs_cbuf))
          {
!             ReleaseBuffer(scan->xs_cbuf);
!             scan->xs_cbuf = InvalidBuffer;
          }
+         return false;
+     }

!     pgstat_count_index_tuples(scan->indexRelation, 1);

!     return true;
! }


! /* ----------------
!  *        index_fetch - fetch the heap tuple the current index pointer points to
!  *
!  * The result is the heap tuple the current index tuple points to if it
!  * matches the snapshot, or NULL if it doesn't. On success, the buffer
!  * containing the heap tuple is pinned (the pin will be dropped at the next
!  * index_fetch or index_endscan).
!  * ----------------
!  */
! HeapTuple
! index_fetch(IndexScanDesc scan)
! {
!     ItemPointer tid = &scan->xs_ctup.t_self;
!     bool        found;
!     Buffer        prev_buf;
!
!     /*
!      * We only fetch the first matching tuple in a chain, so we can't support
!      * SnapshotAny. All other snapshots only consider one tuple in a HOT chain
!      * as visible at any given moment.
!      */
!     Assert(scan->xs_snapshot != SnapshotAny);
!
!     /* Switch to correct buffer if we don't have it already */
!     prev_buf = scan->xs_cbuf;
!     scan->xs_cbuf = ReleaseAndReadBuffer(scan->xs_cbuf,
!                                          scan->heapRelation,
!                                          ItemPointerGetBlockNumber(tid));
!
!     /*
!      * Prune page, but only if we weren't already on this page
!      */
!     if (prev_buf != scan->xs_cbuf)
!         heap_page_prune_opt(scan->heapRelation, scan->xs_cbuf,
!                             RecentGlobalXmin);
!
!     /* Obtain share-lock on the buffer so we can examine visibility */
!     LockBuffer(scan->xs_cbuf, BUFFER_LOCK_SHARE);
!
!     found = heap_hot_search_buffer(tid, scan->xs_cbuf,
!                                    scan->xs_snapshot, &scan->xs_ctup,
!                                    &scan->kill_prior_tuple, true);
!     LockBuffer(scan->xs_cbuf, BUFFER_LOCK_UNLOCK);
!
!     if (found)
      {
!         Assert(!scan->kill_prior_tuple);
!
!         /*
!          * We must initialize all of *heapTuple (ie, scan->xs_ctup) since
!          * it is returned to the executor on success.
!          */
!         scan->xs_ctup.t_tableOid = RelationGetRelid(scan->heapRelation);
!
!         pgstat_count_heap_fetch(scan->indexRelation);
!
!         return &scan->xs_ctup;
      }
+     else
+         return NULL;
+ }

! /* ----------------
!  *        index_getnext - get the next heap tuple from a scan
!  *
!  * This is a shorthand for index_next() + index_fetch().
!  *
!  * The result is the next heap tuple satisfying the scan keys and the
!  * snapshot, or NULL if no more matching tuples exist.    On success,
!  * the buffer containing the heap tuple is pinned (the pin will be dropped
!  * at the next index_getnext or index_endscan).
!  *
!  * Note: caller must check scan->xs_recheck, and perform rechecking of the
!  * scan keys if required.  We do not do that here because we don't have
!  * enough information to do it efficiently in the general case.
!  * ----------------
!  */
! HeapTuple
! index_getnext(IndexScanDesc scan, ScanDirection direction)
! {
!     for(;;)
!     {
!         HeapTuple tup;
!
!         if (!index_next(scan, direction))
!             return NULL;
!
!         tup = index_fetch(scan);
!         if (tup != NULL)
!             return tup;
!     }
  }

  /* ----------------
*** a/src/backend/commands/cluster.c
--- b/src/backend/commands/cluster.c
***************
*** 772,777 **** copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex)
--- 772,778 ----
      TransactionId OldestXmin;
      TransactionId FreezeXid;
      RewriteState rwstate;
+     ItemPointerData tid;

      /*
       * Open the relations we need.
***************
*** 829,847 **** copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex)
      scan = index_beginscan(OldHeap, OldIndex,
                             SnapshotAny, 0, (ScanKey) NULL);

!     while ((tuple = index_getnext(scan, ForwardScanDirection)) != NULL)
      {
          HeapTuple    copiedTuple;
          bool        isdead;
          int            i;

          CHECK_FOR_INTERRUPTS();

!         /* Since we used no scan keys, should never need to recheck */
!         if (scan->xs_recheck)
!             elog(ERROR, "CLUSTER does not support lossy index conditions");

!         LockBuffer(scan->xs_cbuf, BUFFER_LOCK_SHARE);

          switch (HeapTupleSatisfiesVacuum(tuple->t_data, OldestXmin,
                                           scan->xs_cbuf))
--- 830,885 ----
      scan = index_beginscan(OldHeap, OldIndex,
                             SnapshotAny, 0, (ScanKey) NULL);

!     tuple = NULL;
!     for(;;)
      {
          HeapTuple    copiedTuple;
          bool        isdead;
          int            i;
+         bool        found;

          CHECK_FOR_INTERRUPTS();

!         /* Advance to next index tuple if we're done with current HOT chain */
!         if (tuple == NULL)
!         {
!             if (!index_next(scan, ForwardScanDirection))
!                 break;
!
!             /* Since we used no scan keys, should never need to recheck */
!             if (scan->xs_recheck)
!                 elog(ERROR, "CLUSTER does not support lossy index conditions");
!
!             tid = scan->xs_ctup.t_self;

!             scan->xs_cbuf = ReleaseAndReadBuffer(scan->xs_cbuf, OldHeap,
!                                                  ItemPointerGetBlockNumber(&tid));
!             /* Obtain share-lock on the buffer so we can examine visibility */
!             LockBuffer(scan->xs_cbuf, BUFFER_LOCK_SHARE);
!             found = heap_hot_search_buffer(&tid, scan->xs_cbuf,
!                                            scan->xs_snapshot, &scan->xs_ctup,
!                                            &scan->kill_prior_tuple, true);
!             if (!found)
!             {
!                 LockBuffer(scan->xs_cbuf, BUFFER_LOCK_UNLOCK);
!                 break;
!             }
!         }
!         else
!         {
!             /* Fetch next tuple from current HOT chain */
!             LockBuffer(scan->xs_cbuf, BUFFER_LOCK_SHARE);
!             found = heap_hot_search_buffer(&tid, scan->xs_cbuf,
!                                            scan->xs_snapshot, &scan->xs_ctup,
!                                            &scan->kill_prior_tuple, false);
!             if (!found)
!             {
!                 LockBuffer(scan->xs_cbuf, BUFFER_LOCK_UNLOCK);
!                 tuple = NULL;
!                 continue;
!             }
!         }
!         tuple = &scan->xs_ctup;

          switch (HeapTupleSatisfiesVacuum(tuple->t_data, OldestXmin,
                                           scan->xs_cbuf))
*** a/src/backend/executor/nodeBitmapHeapscan.c
--- b/src/backend/executor/nodeBitmapHeapscan.c
***************
*** 382,390 **** bitgetpage(HeapScanDesc scan, TBMIterateResult *tbmres)
          {
              OffsetNumber offnum = tbmres->offsets[curslot];
              ItemPointerData tid;

              ItemPointerSet(&tid, page, offnum);
!             if (heap_hot_search_buffer(&tid, buffer, snapshot, NULL))
                  scan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
          }
      }
--- 382,392 ----
          {
              OffsetNumber offnum = tbmres->offsets[curslot];
              ItemPointerData tid;
+             HeapTupleData heapTuple;

              ItemPointerSet(&tid, page, offnum);
!             if (heap_hot_search_buffer(&tid, buffer, snapshot, &heapTuple,
!                                        NULL, true))
                  scan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
          }
      }
*** a/src/include/access/genam.h
--- b/src/include/access/genam.h
***************
*** 117,122 **** extern void index_endscan(IndexScanDesc scan);
--- 117,125 ----
  extern void index_markpos(IndexScanDesc scan);
  extern void index_restrpos(IndexScanDesc scan);
  extern HeapTuple index_getnext(IndexScanDesc scan, ScanDirection direction);
+ extern bool index_next(IndexScanDesc scan, ScanDirection direction);
+ extern HeapTuple index_fetch(IndexScanDesc scan);
+
  extern int64 index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap);

  extern IndexBulkDeleteResult *index_bulk_delete(IndexVacuumInfo *info,
*** a/src/include/access/heapam.h
--- b/src/include/access/heapam.h
***************
*** 83,89 **** extern bool heap_fetch(Relation relation, Snapshot snapshot,
             HeapTuple tuple, Buffer *userbuf, bool keep_buf,
             Relation stats_relation);
  extern bool heap_hot_search_buffer(ItemPointer tid, Buffer buffer,
!                        Snapshot snapshot, bool *all_dead);
  extern bool heap_hot_search(ItemPointer tid, Relation relation,
                  Snapshot snapshot, bool *all_dead);

--- 83,90 ----
             HeapTuple tuple, Buffer *userbuf, bool keep_buf,
             Relation stats_relation);
  extern bool heap_hot_search_buffer(ItemPointer tid, Buffer buffer,
!                        Snapshot snapshot, HeapTuple tuple,
!                        bool *all_dead, bool firstCall);
  extern bool heap_hot_search(ItemPointer tid, Relation relation,
                  Snapshot snapshot, bool *all_dead);

*** a/src/include/access/relscan.h
--- b/src/include/access/relscan.h
***************
*** 77,87 **** typedef struct IndexScanDescData
      Buffer        xs_cbuf;        /* current heap buffer in scan, if any */
      /* NB: if xs_cbuf is not InvalidBuffer, we hold a pin on that buffer */
      bool        xs_recheck;        /* T means scan keys must be rechecked */
-
-     /* state data for traversing HOT chains in index_getnext */
-     bool        xs_hot_dead;    /* T if all members of HOT chain are dead */
-     OffsetNumber xs_next_hot;    /* next member of HOT chain, if any */
-     TransactionId xs_prev_xmax; /* previous HOT chain member's XMAX, if any */
  } IndexScanDescData;

  /* Struct for heap-or-index scans of system tables */
--- 77,82 ----