Fix misuse of table_index_fetch_tuple_check().

Commit 0d861bbb, which added deduplication to nbtree, had
_bt_check_unique() pass a TID to table_index_fetch_tuple_check() that
isn't safe to mutate.  table_index_fetch_tuple_check()'s tid argument is
modified when the TID in question is not the latest visible tuple in a
hot chain, though this wasn't documented.

To fix, go back to using a local copy of the TID in _bt_check_unique(),
and update comments above table_index_fetch_tuple_check().

Backpatch: 13-, where B-Tree deduplication was introduced.

diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 55fe16bd4e12d26fc77cfa58a1bf43d85dd047a5..b86c122763ebb784a845f0ef8d2d3c18356bac6f 100644 (file)
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -597,7 +597,8 @@ _bt_check_unique(Relation rel, BTInsertState insertstate, Relation heapRel,
                     * not part of this chain because it had a different index
                     * entry.
                     */
-                   if (table_index_fetch_tuple_check(heapRel, &itup->t_tid,
+                   htid = itup->t_tid;
+                   if (table_index_fetch_tuple_check(heapRel, &htid,
                                                      SnapshotSelf, NULL))
                    {
                        /* Normal case --- it's still live */

diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index c814733b2222e3e08992d57295c90bd77b780dc3..4b2bb29559a72aac9436e112060b3b1d5b1d7069 100644 (file)
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -196,6 +196,10 @@ table_beginscan_parallel(Relation relation, ParallelTableScanDesc parallel_scan)
  * optimized, but is unlikely to matter from a performance POV. If there
  * frequently are live index pointers also matching a unique index key, the
  * CPU overhead of this routine is unlikely to matter.
+ *
+ * Note that *tid may be modified when we return true if the AM supports
+ * storing multiple row versions reachable via a single index entry (like
+ * heap's HOT).
  */
 bool
 table_index_fetch_tuple_check(Relation rel,

diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h
index eb18739c36505aac1636a35cbc43e8df6be94b41..b3d2a6dd31509b303b1e50ec38a96fec8af52dfb 100644 (file)
--- a/src/include/access/tableam.h
+++ b/src/include/access/tableam.h
@@ -989,7 +989,9 @@ table_index_fetch_end(struct IndexFetchTableData *scan)
 /*
  * Fetches, as part of an index scan, tuple at `tid` into `slot`, after doing
  * a visibility test according to `snapshot`. If a tuple was found and passed
- * the visibility test, returns true, false otherwise.
+ * the visibility test, returns true, false otherwise. Note that *tid may be
+ * modified when we return true (see later remarks on multiple row versions
+ * reachable via a single index entry).
  *
  * *call_again needs to be false on the first call to table_index_fetch_tuple() for
  * a tid. If there potentially is another tuple matching the tid, *call_again