Evade extra table_tuple_fetch_row_version() in ExecUpdate()/ExecDelete()

When we lock tuple using table_tuple_lock() then we at the same time fetch
the locked tuple to the slot.  In this case we can skip extra
table_tuple_fetch_row_version() thank to we've already fetched the 'old' tuple
and nobody can change it concurrently since it's locked.

Discussion: https://postgr.es/m/CAPpHfdua-YFw3XTprfutzGp28xXLigFtzNbuFY8yPhqeq6X5kg%40mail.gmail.com
Reviewed-by: Aleksander Alekseev, Pavel Borisov, Vignesh C, Mason Sharp
Reviewed-by: Andres Freund, Chris Travers

diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 3a673895082a170914bcadd6da479bb1afc349b5..93ebfdbb0d83080ea4676d7a4fd07c3d1e80f887 100644 (file)
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1559,6 +1559,22 @@ ldelete:
                                        {
                                                case TM_Ok:
                                                        Assert(context->tmfd.traversed);
+
+                                                       /*
+                                                        * Save locked tuple for further processing of
+                                                        * RETURNING clause.
+                                                        */
+                                                       if (processReturning &&
+                                                               resultRelInfo->ri_projectReturning &&
+                                                               !resultRelInfo->ri_FdwRoutine)
+                                                       {
+                                                               TupleTableSlot *returningSlot;
+
+                                                               returningSlot = ExecGetReturningSlot(estate, resultRelInfo);
+                                                               ExecCopySlot(returningSlot, inputslot);
+                                                               ExecMaterializeSlot(returningSlot);
+                                                       }
+
                                                        epqslot = EvalPlanQual(context->epqstate,
                                                                                                   resultRelationDesc,
                                                                                                   resultRelInfo->ri_RangeTableIndex,
@@ -1673,12 +1689,17 @@ ldelete:
                }
                else
                {
+                       /*
+                        * Tuple can be already fetched to the returning slot in case
+                        * we've previously locked it.  Fetch the tuple only if the slot
+                        * is empty.
+                        */
                        slot = ExecGetReturningSlot(estate, resultRelInfo);
                        if (oldtuple != NULL)
                        {
                                ExecForceStoreHeapTuple(oldtuple, slot, false);
                        }
-                       else
+                       else if (TupIsNull(slot))
                        {
                                if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid,
                                                                                                   SnapshotAny, slot))
@@ -2393,6 +2414,19 @@ redo_act:
                                                case TM_Ok:
                                                        Assert(context->tmfd.traversed);
 
+                                                       /* Make sure ri_oldTupleSlot is initialized. */
+                                                       if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
+                                                               ExecInitUpdateProjection(context->mtstate,
+                                                                                                                resultRelInfo);
+
+                                                       /*
+                                                        * Save the locked tuple for further calculation
+                                                        * of the new tuple.
+                                                        */
+                                                       oldSlot = resultRelInfo->ri_oldTupleSlot;
+                                                       ExecCopySlot(oldSlot, inputslot);
+                                                       ExecMaterializeSlot(oldSlot);
+
                                                        epqslot = EvalPlanQual(context->epqstate,
                                                                                                   resultRelationDesc,
                                                                                                   resultRelInfo->ri_RangeTableIndex,
@@ -2401,18 +2435,6 @@ redo_act:
                                                                /* Tuple not passing quals anymore, exiting... */
                                                                return NULL;
 
-                                                       /* Make sure ri_oldTupleSlot is initialized. */
-                                                       if (unlikely(!resultRelInfo->ri_projectNewInfoValid))
-                                                               ExecInitUpdateProjection(context->mtstate,
-                                                                                                                resultRelInfo);
-
-                                                       /* Fetch the most recent version of old tuple. */
-                                                       oldSlot = resultRelInfo->ri_oldTupleSlot;
-                                                       if (!table_tuple_fetch_row_version(resultRelationDesc,
-                                                                                                                          tupleid,
-                                                                                                                          SnapshotAny,
-                                                                                                                          oldSlot))
-                                                               elog(ERROR, "failed to fetch tuple being updated");
                                                        slot = ExecGetUpdateNewTuple(resultRelInfo,
                                                                                                                 epqslot, oldSlot);
                                                        goto redo_act;