Make detach-partition-concurrently-3 less timing-sensitive

This recently added test has shown to be too sensitive to timing when
sending a cancel to a session waiting for a lock.

We fix this by running a no-op query in the blocked session immediately
after the cancel; this avoids the session that sent the cancel sending
another query immediately before the cancel has been reported.
Idea by Noah Misch.

With that fix, we sometimes see that the cancel error report is shown
only relative to the step that is cancelled, instead of together with
the step that sends the cancel.  To increase the probability that both
steps are shown togeter, add a 0.1s sleep to the cancel.  In normal
conditions this appears sufficient to silence most failures, but we'll
see that the slower buildfarm members say about it.

Reported-by: Takamichi Osumi <osumi.takamichi@fujitsu.com>
Discussion: https://postgr.es/m/OSBPR01MB4888C4ABA361C7E81094AC66ED269@OSBPR01MB4888.jpnprd01.prod.outlook.com

diff --git a/src/test/isolation/expected/detach-partition-concurrently-3.out b/src/test/isolation/expected/detach-partition-concurrently-3.out
index bbb9d151fb7f98e5f6f5c3db85c10d2538adbe69..96ee090d531cd127dd0f3db0ae425ce104b372cf 100644 (file)
--- a/src/test/isolation/expected/detach-partition-concurrently-3.out
+++ b/src/test/isolation/expected/detach-partition-concurrently-3.out
@@ -1,6 +1,6 @@
 Parsed test spec with 2 sessions
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1describe s1alter
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1describe s1alter
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -8,12 +8,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1describe: SELECT 'd3_listp' AS root, * FROM pg_partition_tree('d3_listp')
                                          UNION ALL SELECT 'd3_listp1', * FROM pg_partition_tree('d3_listp1');
@@ -25,7 +26,7 @@ d3_listp1      d3_listp1                     t              0
 step s1alter: ALTER TABLE d3_listp1 ALTER a DROP NOT NULL;
 ERROR:  cannot alter partition "d3_listp1" with an incomplete detach
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1insert s1c
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1insert s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -33,17 +34,18 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1insert: INSERT INTO d3_listp VALUES (1);
 ERROR:  no partition of relation "d3_listp" found for row
 step s1c: COMMIT;
 
-starting permutation: s2snitch s1brr s1s s2detach s1cancel s1insert s1c s1spart
+starting permutation: s2snitch s1brr s1s s2detach s1cancel s2noop s1insert s1c s1spart
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
 step s1s: SELECT * FROM d3_listp;
@@ -51,12 +53,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1insert: INSERT INTO d3_listp VALUES (1);
 step s1c: COMMIT;
 step s1spart: SELECT * FROM d3_listp1;
@@ -65,7 +68,7 @@ a
 1              
 1              
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1insertpart
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1insertpart
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -73,16 +76,17 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1insertpart: INSERT INTO d3_listp1 VALUES (1);
 
-starting permutation: s2snitch s1b s1s s2detach2 s1cancel s1c s1brr s1insert s1s s1insert s1c
+starting permutation: s2snitch s1b s1s s2detach2 s1cancel s2noop s1c s1brr s1insert s1s s1insert s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -90,12 +94,13 @@ a
 
 1              
 step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach2: <... completed>
 error in steps s1cancel s2detach2: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
 step s1insert: INSERT INTO d3_listp VALUES (1);
@@ -107,7 +112,7 @@ a
 step s1insert: INSERT INTO d3_listp VALUES (1);
 step s1c: COMMIT;
 
-starting permutation: s2snitch s1b s1s s2detach2 s1cancel s1c s1brr s1s s1insert s1s s1c
+starting permutation: s2snitch s1b s1s s2detach2 s1cancel s2noop s1c s1brr s1s s1insert s1s s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -115,12 +120,13 @@ a
 
 1              
 step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach2: <... completed>
 error in steps s1cancel s2detach2: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
 step s1s: SELECT * FROM d3_listp;
@@ -135,7 +141,7 @@ a
 1              
 step s1c: COMMIT;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1drop s1list
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1drop s1list
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -143,12 +149,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1drop: DROP TABLE d3_listp;
 step s1list: SELECT relname FROM pg_catalog.pg_class
@@ -156,7 +163,7 @@ step s1list: SELECT relname FROM pg_catalog.pg_class
 relname        
 
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1trunc s1spart
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1trunc s1spart
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -164,12 +171,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1trunc: TRUNCATE TABLE d3_listp;
 step s1spart: SELECT * FROM d3_listp1;
@@ -177,7 +185,7 @@ a
 
 1              
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s2detach2 s1c
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s2detach2 s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -185,17 +193,18 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
 ERROR:  partition "d3_listp1" already pending detach in partitioned table "public.d3_listp"
 step s1c: COMMIT;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s2detachfinal s1c s2detach2
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s2detachfinal s1c s2detach2
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -203,18 +212,19 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <waiting ...>
 step s1c: COMMIT;
 step s2detachfinal: <... completed>
 step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1droppart s2detach2
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1droppart s2detach2
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -222,17 +232,18 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1droppart: DROP TABLE d3_listp1;
 step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2drop s1s s2commit
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2drop s1s s2commit
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -240,12 +251,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s2begin: BEGIN;
 step s2drop: DROP TABLE d3_listp1;
@@ -255,7 +267,7 @@ step s1s: <... completed>
 a              
 
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1spart s2detachfinal s1c
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1spart s2detachfinal s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -263,12 +275,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1b: BEGIN;
 step s1spart: SELECT * FROM d3_listp1;
@@ -279,7 +292,7 @@ step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <w
 step s1c: COMMIT;
 step s2detachfinal: <... completed>
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1s s2detachfinal s1c
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1s s2detachfinal s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -287,12 +300,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -301,7 +315,7 @@ a
 step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
 step s1c: COMMIT;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1spart s2detachfinal s1c
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1spart s2detachfinal s1c
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -309,12 +323,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s1b: BEGIN;
 step s1spart: SELECT * FROM d3_listp1;
@@ -325,7 +340,7 @@ step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <w
 step s1c: COMMIT;
 step s2detachfinal: <... completed>
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s2commit
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s2commit
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -333,18 +348,19 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s2begin: BEGIN;
 step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
 step s2commit: COMMIT;
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s1spart s2commit
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s1spart s2commit
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -352,12 +368,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s2begin: BEGIN;
 step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
@@ -368,7 +385,7 @@ a
 
 1              
 
-starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s1insertpart s2commit
+starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s1insertpart s2commit
 step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
 step s1b: BEGIN;
 step s1s: SELECT * FROM d3_listp;
@@ -376,12 +393,13 @@ a
 
 1              
 step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
-step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
-pg_cancel_backend
+step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
+pg_cancel_backendpg_sleep       
 
-t              
+t                             
 step s2detach: <... completed>
 error in steps s1cancel s2detach: ERROR:  canceling statement due to user request
+step s2noop: UNLISTEN noop;
 step s1c: COMMIT;
 step s2begin: BEGIN;
 step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;

diff --git a/src/test/isolation/specs/detach-partition-concurrently-3.spec b/src/test/isolation/specs/detach-partition-concurrently-3.spec
index 5a8351fc83ebd201d35c1a20d9c5397737a04e03..13ad84ac03739d434e150cd12fa614f5686657fa 100644 (file)
--- a/src/test/isolation/specs/detach-partition-concurrently-3.spec
+++ b/src/test/isolation/specs/detach-partition-concurrently-3.spec
@@ -1,4 +1,8 @@
 # Try various things to happen to a partition with an incomplete detach
+#
+# Note: Always keep "s2noop" right after "s1cancel" in permutations.  This
+# reduces the probability of the timing problem that the cancel error report
+# is shown together with the next query instead of with the cancel query.
 
 setup
 {
@@ -18,7 +22,8 @@ step "s1b"                    { BEGIN; }
 step "s1brr"           { BEGIN ISOLATION LEVEL REPEATABLE READ; }
 step "s1s"                     { SELECT * FROM d3_listp; }
 step "s1spart"         { SELECT * FROM d3_listp1; }
-step "s1cancel"                { SELECT pg_cancel_backend(pid) FROM d3_pid; }
+# Sleep 0.1s after sending cancel, to give s2 time to react
+step "s1cancel"        { SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid; }
 step "s1c"                     { COMMIT; }
 step "s1alter"         { ALTER TABLE d3_listp1 ALTER a DROP NOT NULL; }
 step "s1insert"                { INSERT INTO d3_listp VALUES (1); }
@@ -36,43 +41,44 @@ step "s2begin"              { BEGIN; }
 step "s2snitch"                { INSERT INTO d3_pid SELECT pg_backend_pid(); }
 step "s2detach"                { ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; }
 step "s2detach2"       { ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; }
+step "s2noop"          { UNLISTEN noop; }
 step "s2detachfinal"   { ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; }
 step "s2drop"          { DROP TABLE d3_listp1; }
 step "s2commit"                { COMMIT; }
 
 # Try various things while the partition is in "being detached" state, with
 # no session waiting.
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1describe" "s1alter"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1insert" "s1c"
-permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1cancel" "s1insert" "s1c" "s1spart"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1insertpart"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1describe" "s1alter"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c"
+permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c" "s1spart"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1insertpart"
 
 # Test partition descriptor caching
-permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s1c" "s1brr" "s1insert" "s1s" "s1insert" "s1c"
-permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s1c" "s1brr" "s1s" "s1insert" "s1s" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s2noop" "s1c" "s1brr" "s1insert" "s1s" "s1insert" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s2noop" "s1c" "s1brr" "s1s" "s1insert" "s1s" "s1c"
 
 # "drop" here does both tables
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1drop" "s1list"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1drop" "s1list"
 # "truncate" only does parent, not partition
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1trunc" "s1spart"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1trunc" "s1spart"
 
 # If a partition pending detach exists, we cannot drop another one
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2detach2" "s1c"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2detachfinal" "s1c" "s2detach2"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1droppart" "s2detach2"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s2detach2" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s2detachfinal" "s1c" "s2detach2"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1droppart" "s2detach2"
 
 # When a partition with incomplete detach is dropped, we grab lock on parent too.
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s2begin" "s2drop" "s1s" "s2commit"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2drop" "s1s" "s2commit"
 
 # Partially detach, then select and try to complete the detach.  Reading
 # from partition blocks (AEL is required on partition); reading from parent
 # does not block.
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1b" "s1s" "s2detachfinal" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1s" "s2detachfinal" "s1c"
 
 # DETACH FINALIZE in a transaction block. No insert/select on the partition
 # is allowed concurrently with that.
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s2begin" "s2detachfinal" "s2commit"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s2begin" "s2detachfinal" "s1spart" "s2commit"
-permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s1c" "s2begin" "s2detachfinal" "s1insertpart" "s2commit"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s2commit"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s1spart" "s2commit"
+permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s1insertpart" "s2commit"