Add injection-point test for the prune-before-lock relock fallback

PortalRunMulti() reuses a cached generic plan's Bind-time partition
pruning only while the command counter has not advanced; otherwise it
discards the prepared state and re-locks conservatively, failing with
serialization_failure if the plan was invalidated in between.  That
fallback is only reachable in a pipelined transaction, so add a
"cached-plan-relock" injection point that both diverts an ordinary
EXECUTE into the fallback and provides a wait in the re-lock window,
and an isolation test covering the two outcomes: the fallback running
to completion when the plan is still valid, and serialization_failure
when a concurrent session invalidates it during the wait.

Author: amitlan

src/backend/tcop/pquery.c

@@ -25,6 +25,7 @@
 #include "pg_trace.h"
 #include "tcop/pquery.h"
 #include "tcop/utility.h"
+#include "utils/injection_point.h"
 #include "utils/memutils.h"
 #include "utils/snapmgr.h"
 
@@ -1363,7 +1364,8 @@ PortalRunMulti(Portal portal,
 				Assert(pstmt->canSetTag);
 				Assert(!active_snapshot_set);
 
-				if (prep_qd->snapshot->curcid == GetCurrentCommandId(false))
+				if (prep_qd->snapshot->curcid == GetCurrentCommandId(false) &&
+					!IS_INJECTION_POINT_ATTACHED("cached-plan-relock"))
 				{
 					PushActiveSnapshot(prep_qd->snapshot);
 					ProcessQuery(pstmt,
@@ -1399,6 +1401,16 @@ PortalRunMulti(Portal portal,
 				 */
 				PortalDisposePrepQueryDesc(portal);
 
+				/*
+				 * Test hook: a concurrent invalidation must be able to land
+				 * here, between discarding the Bind-time prep and the
+				 * conservative re-lock, to exercise the serialization_failure
+				 * path below.  Attaching this point also forces the fast path
+				 * above to be skipped, so an ordinary (non-pipelined) EXECUTE
+				 * reaches this branch.  Compiles out without injection points.
+				 */
+				INJECTION_POINT("cached-plan-relock", NULL);
+
 				/*
 				 * Note that this locks all partitions instead of redoing the
 				 * initial pruning as ExecutorPrepAndLock() would have at

src/test/modules/injection_points/Makefile

@@ -19,7 +19,8 @@ ISOLATION = basic \
 	    repack_temporal_multirange \
 	    repack_toast \
 	    syscache-update-pruned \
-	    heap_lock_update
+	    heap_lock_update \
+	    cached_plan_relock
 
 # some isolation tests require wal_level=replica
 ISOLATION_OPTS = --temp-config $(top_srcdir)/src/test/modules/injection_points/extra.conf

src/test/modules/injection_points/expected/cached_plan_relock.out

@@ -0,0 +1,55 @@
+Parsed test spec with 2 sessions
+
+starting permutation: arm_notice exec
+injection_points_set_local
+--------------------------
+                          
+(1 row)
+
+step arm_notice: SELECT injection_points_attach('cached-plan-relock', 'notice');
+injection_points_attach
+-----------------------
+                       
+(1 row)
+
+s1: NOTICE:  notice triggered for injection point cached-plan-relock
+step exec: EXECUTE p (1);
+a
+-
+1
+(1 row)
+
+injection_points_detach
+-----------------------
+                       
+(1 row)
+
+
+starting permutation: arm_wait exec invalidate wakeup noop
+injection_points_set_local
+--------------------------
+                          
+(1 row)
+
+step arm_wait: SELECT injection_points_attach('cached-plan-relock', 'wait');
+injection_points_attach
+-----------------------
+                       
+(1 row)
+
+step exec: EXECUTE p (1); <waiting ...>
+step invalidate: CREATE INDEX cpr3_a_idx ON cpr3 (a);
+step wakeup: SELECT injection_points_wakeup('cached-plan-relock');
+injection_points_wakeup
+-----------------------
+                       
+(1 row)
+
+step exec: <... completed>
+ERROR:  cached plan was invalidated during execution setup
+step noop: 
+injection_points_detach
+-----------------------
+                       
+(1 row)
+

src/test/modules/injection_points/meson.build

@@ -51,6 +51,7 @@ tests += {
       'repack_toast',
       'syscache-update-pruned',
       'heap_lock_update',
+      'cached_plan_relock',
     ],
     'runningcheck': false, # see syscache-update-pruned
     # Some tests wait for all snapshots, so avoid parallel execution

src/test/modules/injection_points/specs/cached_plan_relock.spec

@@ -0,0 +1,68 @@
+# Exercise the fallback in PortalRunMulti() taken when a reused generic
+# plan's Bind-time partition-pruning survivor set may be stale (the
+# command counter advanced between Bind and Execute).  That fallback
+# discards the prepared state and re-locks conservatively; if the plan
+# was invalidated in the meantime the statement fails with
+# serialization_failure.
+#
+# The fallback is normally only reachable in a pipelined transaction
+# (named portals executed out of Bind order).  The "cached-plan-relock"
+# injection point stands in for that: while it is attached, an ordinary
+# EXECUTE is diverted into the fallback, and the point also provides a
+# wait so a concurrent invalidation can be placed precisely in the
+# re-lock window.
+
+setup
+{
+	CREATE EXTENSION injection_points;
+
+	CREATE TABLE cpr (a int, b int) PARTITION BY LIST (a);
+	CREATE TABLE cpr1 PARTITION OF cpr FOR VALUES IN (1);
+	CREATE TABLE cpr2 PARTITION OF cpr FOR VALUES IN (2);
+	CREATE TABLE cpr3 PARTITION OF cpr FOR VALUES IN (3);
+	INSERT INTO cpr SELECT g, 0 FROM generate_series(1, 3) g;
+}
+
+teardown
+{
+	DROP TABLE cpr;
+	DROP EXTENSION injection_points;
+}
+
+session s1
+setup
+{
+	SET plan_cache_mode = force_generic_plan;
+	-- session setup runs at the start of every permutation on the same
+	-- connection, so clear any prepared statement left by a prior one
+	DEALLOCATE ALL;
+	PREPARE p (int) AS UPDATE cpr SET b = b + 1 WHERE a = $1 RETURNING a;
+	-- first EXECUTE builds the generic plan (not yet "reused", so it does
+	-- not take the prune-before-lock path); the plan is reused afterwards
+	EXECUTE p (1);
+	SELECT injection_points_set_local();
+}
+# attach as 'notice': force the fallback but let it run through
+step arm_notice	{ SELECT injection_points_attach('cached-plan-relock', 'notice'); }
+# attach as 'wait': force the fallback and park in the re-lock window
+step arm_wait	{ SELECT injection_points_attach('cached-plan-relock', 'wait'); }
+step exec		{ EXECUTE p (1); }
+step noop		{ }
+teardown		{ SELECT injection_points_detach('cached-plan-relock'); }
+
+session s2
+# invalidate the cached plan on a partition s1 does not hold locked at
+# Bind (it pruned to cpr1), so this does not block on s1
+step invalidate	{ CREATE INDEX cpr3_a_idx ON cpr3 (a); }
+step wakeup		{ SELECT injection_points_wakeup('cached-plan-relock'); }
+
+# Fallback runs to completion when the plan is still valid: the reused
+# generic plan is discarded, re-locked conservatively, and executed,
+# returning the correct row (a = 1).
+permutation arm_notice exec
+
+# Fallback meets a concurrent invalidation: s1 parks at the re-lock
+# point, s2 invalidates the plan and wakes s1, whose conservative
+# AcquireExecutorLocks() then reports the plan invalid, raising
+# serialization_failure.  The noop keeps detach ordered after the wait.
+permutation arm_wait exec invalidate wakeup noop