Add TupleTableSlotOps.is_current_xact_tuple() method

This allows us to abstract how/whether table AM uses transaction identifiers.
A custom table AM can use a custom slot, which may not store xmin directly,
but determine the tuple belonging to the current transaction in the other way.

Discussion: https://postgr.es/m/CAPpHfdurb9ycV8udYqM%3Do0sPS66PJ4RCBM1g-bBpvzUfogY0EA%40mail.gmail.com
Reviewed-by: Matthias van de Meent, Mark Dilger, Pavel Borisov
Reviewed-by: Nikita Malakhov, Japin Li

diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index a7aa2ee02b1ed61cac26f9e5c8f70f6dad9d38bb..7a7c78604167f79445562e9bd466039ec9fdd4e2 100644 (file)
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -60,6 +60,7 @@
 #include "access/heaptoast.h"
 #include "access/htup_details.h"
 #include "access/tupdesc_details.h"
+#include "access/xact.h"
 #include "catalog/pg_type.h"
 #include "funcapi.h"
 #include "nodes/nodeFuncs.h"
@@ -148,6 +149,22 @@ tts_virtual_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
    return 0;                   /* silence compiler warnings */
 }
 
+/*
+ * VirtualTupleTableSlots never have storage tuples.  We generally
+ * shouldn't get here, but provide a user-friendly message if we do.
+ */
+static bool
+tts_virtual_is_current_xact_tuple(TupleTableSlot *slot)
+{
+   Assert(!TTS_EMPTY(slot));
+
+   ereport(ERROR,
+           (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+            errmsg("don't have a storage tuple in this context")));
+
+   return false;               /* silence compiler warnings */
+}
+
 /*
  * To materialize a virtual slot all the datums that aren't passed by value
  * have to be copied into the slot's memory context.  To do so, compute the
@@ -354,6 +371,29 @@ tts_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
                           slot->tts_tupleDescriptor, isnull);
 }
 
+static bool
+tts_heap_is_current_xact_tuple(TupleTableSlot *slot)
+{
+   HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
+   TransactionId xmin;
+
+   Assert(!TTS_EMPTY(slot));
+
+   /*
+    * In some code paths it's possible to get here with a non-materialized
+    * slot, in which case we can't check if tuple is created by the current
+    * transaction.
+    */
+   if (!hslot->tuple)
+       ereport(ERROR,
+               (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+                errmsg("don't have a storage tuple in this context")));
+
+   xmin = HeapTupleHeaderGetRawXmin(hslot->tuple->t_data);
+
+   return TransactionIdIsCurrentTransactionId(xmin);
+}
+
 static void
 tts_heap_materialize(TupleTableSlot *slot)
 {
@@ -521,6 +561,18 @@ tts_minimal_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
    return 0;                   /* silence compiler warnings */
 }
 
+static bool
+tts_minimal_is_current_xact_tuple(TupleTableSlot *slot)
+{
+   Assert(!TTS_EMPTY(slot));
+
+   ereport(ERROR,
+           (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+            errmsg("don't have a storage tuple in this context")));
+
+   return false;               /* silence compiler warnings */
+}
+
 static void
 tts_minimal_materialize(TupleTableSlot *slot)
 {
@@ -714,6 +766,29 @@ tts_buffer_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
                           slot->tts_tupleDescriptor, isnull);
 }
 
+static bool
+tts_buffer_is_current_xact_tuple(TupleTableSlot *slot)
+{
+   BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
+   TransactionId xmin;
+
+   Assert(!TTS_EMPTY(slot));
+
+   /*
+    * In some code paths it's possible to get here with a non-materialized
+    * slot, in which case we can't check if tuple is created by the current
+    * transaction.
+    */
+   if (!bslot->base.tuple)
+       ereport(ERROR,
+               (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+                errmsg("don't have a storage tuple in this context")));
+
+   xmin = HeapTupleHeaderGetRawXmin(bslot->base.tuple->t_data);
+
+   return TransactionIdIsCurrentTransactionId(xmin);
+}
+
 static void
 tts_buffer_heap_materialize(TupleTableSlot *slot)
 {
@@ -1029,6 +1104,7 @@ const TupleTableSlotOps TTSOpsVirtual = {
    .getsomeattrs = tts_virtual_getsomeattrs,
    .getsysattr = tts_virtual_getsysattr,
    .materialize = tts_virtual_materialize,
+   .is_current_xact_tuple = tts_virtual_is_current_xact_tuple,
    .copyslot = tts_virtual_copyslot,
 
    /*
@@ -1048,6 +1124,7 @@ const TupleTableSlotOps TTSOpsHeapTuple = {
    .clear = tts_heap_clear,
    .getsomeattrs = tts_heap_getsomeattrs,
    .getsysattr = tts_heap_getsysattr,
+   .is_current_xact_tuple = tts_heap_is_current_xact_tuple,
    .materialize = tts_heap_materialize,
    .copyslot = tts_heap_copyslot,
    .get_heap_tuple = tts_heap_get_heap_tuple,
@@ -1065,6 +1142,7 @@ const TupleTableSlotOps TTSOpsMinimalTuple = {
    .clear = tts_minimal_clear,
    .getsomeattrs = tts_minimal_getsomeattrs,
    .getsysattr = tts_minimal_getsysattr,
+   .is_current_xact_tuple = tts_minimal_is_current_xact_tuple,
    .materialize = tts_minimal_materialize,
    .copyslot = tts_minimal_copyslot,
 
@@ -1082,6 +1160,7 @@ const TupleTableSlotOps TTSOpsBufferHeapTuple = {
    .clear = tts_buffer_heap_clear,
    .getsomeattrs = tts_buffer_heap_getsomeattrs,
    .getsysattr = tts_buffer_heap_getsysattr,
+   .is_current_xact_tuple = tts_buffer_is_current_xact_tuple,
    .materialize = tts_buffer_heap_materialize,
    .copyslot = tts_buffer_heap_copyslot,
    .get_heap_tuple = tts_buffer_heap_get_heap_tuple,

diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index 2fe937750034d8c2899e30f95ce04ca6a8b683f1..62601a6d80c7be2fe44847f042bb8d2cd943f39b 100644 (file)
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -1260,9 +1260,6 @@ RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel,
 {
    const RI_ConstraintInfo *riinfo;
    int         ri_nullcheck;
-   Datum       xminDatum;
-   TransactionId xmin;
-   bool        isnull;
 
    /*
     * AfterTriggerSaveEvent() handles things such that this function is never
@@ -1330,10 +1327,7 @@ RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel,
     * this if we knew the INSERT trigger already fired, but there is no easy
     * way to know that.)
     */
-   xminDatum = slot_getsysattr(oldslot, MinTransactionIdAttributeNumber, &isnull);
-   Assert(!isnull);
-   xmin = DatumGetTransactionId(xminDatum);
-   if (TransactionIdIsCurrentTransactionId(xmin))
+   if (slot_is_current_xact_tuple(oldslot))
        return true;
 
    /* If all old and new key values are equal, no check is needed */

diff --git a/src/include/executor/tuptable.h b/src/include/executor/tuptable.h
index 6133dbcd0a36c59a2f41a3c3644f75f4f6d94607..b82655e7e55519ae7dc7220ab571de6766c8a153 100644 (file)
--- a/src/include/executor/tuptable.h
+++ b/src/include/executor/tuptable.h
@@ -166,6 +166,12 @@ struct TupleTableSlotOps
     */
    Datum       (*getsysattr) (TupleTableSlot *slot, int attnum, bool *isnull);
 
+   /*
+    * Check if the tuple is created by the current transaction. Throws an
+    * error if the slot doesn't contain the storage tuple.
+    */
+   bool        (*is_current_xact_tuple) (TupleTableSlot *slot);
+
    /*
     * Make the contents of the slot solely depend on the slot, and not on
     * underlying resources (like another memory context, buffers, etc).
@@ -426,6 +432,21 @@ slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
    return slot->tts_ops->getsysattr(slot, attnum, isnull);
 }
 
+/*
+ * slot_is_current_xact_tuple - check if the slot's current tuple is created
+ *                             by the current transaction.
+ *
+ *  If the slot does not contain a storage tuple, this will throw an error.
+ *  Hence before calling this function, callers should make sure that the
+ *  slot type supports storage tuples and that there is currently one inside
+ *  the slot.
+ */
+static inline bool
+slot_is_current_xact_tuple(TupleTableSlot *slot)
+{
+   return slot->tts_ops->is_current_xact_tuple(slot);
+}
+
 /*
  * ExecClearTuple - clear the slot's contents
  */