diff -w -U3 C:/cirrus/src/test/isolation/expected/insert-conflict-specconflict.out C:/cirrus/build/testrun/isolation/isolation/results/insert-conflict-specconflict.out --- C:/cirrus/src/test/isolation/expected/insert-conflict-specconflict.out 2024-04-05 16:07:25.317683900 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/insert-conflict-specconflict.out 2024-04-05 16:10:37.756738900 +0000 @@ -22,532 +22,10 @@ step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 s2: NOTICE: acquiring advisory lock on 3 -step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+----------- -k1 |inserted s2 -(1 row) - -step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step s1_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+----------------------------------- -k1 |inserted s2 with conflict update s1 -(1 row) - - -starting permutation: controller_locks controller_show s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show controller_unlock_2_2 controller_show -step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); -pg_advisory_lock|sess|lock -----------------+----+---- - | 1| 1 - | 1| 2 - | 1| 3 - | 2| 1 - | 2| 2 - | 2| 3 -(6 rows) - -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 3 -step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 3 -step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -step s1_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+----------- -k1 |inserted s1 -(1 row) - -step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step s2_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+----------------------------------- -k1 |inserted s1 with conflict update s2 -(1 row) - - -starting permutation: controller_locks controller_show s1_insert_toast s2_insert_toast controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show_count controller_unlock_2_2 controller_show_count -step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); -pg_advisory_lock|sess|lock -----------------+----+---- - | 1| 1 - | 1| 2 - | 1| 3 - | 2| 1 - | 2| 2 - | 2| 3 -(6 rows) - -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -s1: NOTICE: blurt_and_lock_123() called for k2 in session 1 -s1: NOTICE: acquiring advisory lock on 3 -step s1_insert_toast: INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; -s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 -s2: NOTICE: acquiring advisory lock on 3 -step s2_insert_toast: INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k2 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -step s1_insert_toast: <... completed> -step controller_show_count: SELECT COUNT(*) FROM upserttest; -count ------ - 1 -(1 row) - -step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step s2_insert_toast: <... completed> -step controller_show_count: SELECT COUNT(*) FROM upserttest; -count ------ - 1 -(1 row) - - -starting permutation: controller_locks controller_show s1_begin s2_begin s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show controller_unlock_2_2 controller_show s1_commit controller_show s2_commit controller_show -step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); -pg_advisory_lock|sess|lock -----------------+----+---- - | 1| 1 - | 1| 2 - | 1| 3 - | 2| 1 - | 2| 2 - | 2| 3 -(6 rows) - -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step s1_begin: BEGIN; -step s2_begin: BEGIN; -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 3 -step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 3 -step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -step s1_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step s1_commit: COMMIT; -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step s2_upsert: <... completed> -step controller_show: SELECT * FROM upserttest; -key|data ----+----------- -k1 |inserted s1 -(1 row) - -step s2_commit: COMMIT; -step controller_show: SELECT * FROM upserttest; -key|data ----+----------------------------------- -k1 |inserted s1 with conflict update s2 -(1 row) - - -starting permutation: s1_create_non_unique_index s1_confirm_index_order controller_locks controller_show s2_begin s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_lock_2_4 controller_unlock_2_2 controller_show controller_unlock_1_2 controller_print_speculative_locks controller_unlock_2_4 s2_noop controller_print_speculative_locks s2_commit s1_noop controller_show controller_print_speculative_locks -step s1_create_non_unique_index: CREATE INDEX upserttest_key_idx ON upserttest((blurt_and_lock_4(key))); -step s1_confirm_index_order: SELECT 'upserttest_key_uniq_idx'::regclass::int8 < 'upserttest_key_idx'::regclass::int8; -?column? --------- -t -(1 row) - -step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); -pg_advisory_lock|sess|lock -----------------+----+---- - | 1| 1 - | 1| 2 - | 1| 3 - | 2| 1 - | 2| 2 - | 2| 3 -(6 rows) - -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step s2_begin: BEGIN; -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 3 -step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 3 -step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); -pg_advisory_unlock ------------------- -t -(1 row) - -step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 2 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_lock_2_4: SELECT pg_advisory_lock(2, 4); -pg_advisory_lock ----------------- - -(1 row) - -step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s2: NOTICE: blurt_and_lock_4() called for k1 in session 2 -s2: NOTICE: acquiring advisory lock on 4 -step controller_show: SELECT * FROM upserttest; -key|data ----+---- -(0 rows) - -step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_4() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 4 -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step controller_print_speculative_locks: - SELECT pa.application_name, locktype, mode, granted - FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) - WHERE - locktype IN ('spectoken', 'transactionid') - AND pa.datname = current_database() - AND pa.application_name LIKE 'isolation/insert-conflict-specconflict/s%' - ORDER BY 1, 2, 3, 4; - -application_name |locktype |mode |granted ------------------------------------------+-------------+-------------+------- -isolation/insert-conflict-specconflict/s1|spectoken |ShareLock |f -isolation/insert-conflict-specconflict/s1|transactionid|ExclusiveLock|t -isolation/insert-conflict-specconflict/s2|spectoken |ExclusiveLock|t -isolation/insert-conflict-specconflict/s2|transactionid|ExclusiveLock|t -(4 rows) - -step controller_unlock_2_4: SELECT pg_advisory_unlock(2, 4); -pg_advisory_unlock ------------------- -t -(1 row) - -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step s2_upsert: <... completed> -step s2_noop: -step controller_print_speculative_locks: - SELECT pa.application_name, locktype, mode, granted - FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) - WHERE - locktype IN ('spectoken', 'transactionid') - AND pa.datname = current_database() - AND pa.application_name LIKE 'isolation/insert-conflict-specconflict/s%' - ORDER BY 1, 2, 3, 4; - -application_name |locktype |mode |granted ------------------------------------------+-------------+-------------+------- -isolation/insert-conflict-specconflict/s1|transactionid|ExclusiveLock|t -isolation/insert-conflict-specconflict/s1|transactionid|ShareLock |f -isolation/insert-conflict-specconflict/s2|transactionid|ExclusiveLock|t -(3 rows) - -step s2_commit: COMMIT; -s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 -s1: NOTICE: acquiring advisory lock on 2 -step s1_upsert: <... completed> -step s1_noop: -step controller_show: SELECT * FROM upserttest; -key|data ----+----------------------------------- -k1 |inserted s2 with conflict update s1 -(1 row) - -step controller_print_speculative_locks: - SELECT pa.application_name, locktype, mode, granted - FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) - WHERE - locktype IN ('spectoken', 'transactionid') - AND pa.datname = current_database() - AND pa.application_name LIKE 'isolation/insert-conflict-specconflict/s%' - ORDER BY 1, 2, 3, 4; - -application_name|locktype|mode|granted -----------------+--------+----+------- -(0 rows) +s2: WARNING: terminating connection because of crash of another server process +DETAIL: The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory. +HINT: In a moment you should be able to reconnect to the database and repeat your command. +PQconsumeInput failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request. diff -w -U3 C:/cirrus/src/test/isolation/expected/merge-insert-update.out C:/cirrus/build/testrun/isolation/isolation/results/merge-insert-update.out --- C:/cirrus/src/test/isolation/expected/merge-insert-update.out 2024-04-05 16:07:25.321708900 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/merge-insert-update.out 2024-04-05 16:10:38.508186800 +0000 @@ -1,94 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: merge1 c1 select2 c2 -step merge1: MERGE INTO target t USING (SELECT 1 as key, 'merge1' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge1'; -step c1: COMMIT; -step select2: SELECT * FROM target; -key|val ----+------ - 1|merge1 -(1 row) - -step c2: COMMIT; - -starting permutation: merge1 c1 merge2 select2 c2 -step merge1: MERGE INTO target t USING (SELECT 1 as key, 'merge1' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge1'; -step c1: COMMIT; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step select2: SELECT * FROM target; -key|val ----+------------------------ - 1|merge1 updated by merge2 -(1 row) - -step c2: COMMIT; - -starting permutation: insert1 merge2 c1 select2 c2 -step insert1: INSERT INTO target VALUES (1, 'insert1'); -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step c1: COMMIT; -step merge2: <... completed> -ERROR: duplicate key value violates unique constraint "target_pkey" -step select2: SELECT * FROM target; -ERROR: current transaction is aborted, commands ignored until end of transaction block -step c2: COMMIT; - -starting permutation: merge1 merge2 c1 select2 c2 -step merge1: MERGE INTO target t USING (SELECT 1 as key, 'merge1' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge1'; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step c1: COMMIT; -step merge2: <... completed> -ERROR: duplicate key value violates unique constraint "target_pkey" -step select2: SELECT * FROM target; -ERROR: current transaction is aborted, commands ignored until end of transaction block -step c2: COMMIT; - -starting permutation: merge1 merge2 a1 select2 c2 -step merge1: MERGE INTO target t USING (SELECT 1 as key, 'merge1' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge1'; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step a1: ABORT; -step merge2: <... completed> -step select2: SELECT * FROM target; -key|val ----+------ - 1|merge2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete1 insert1 c1 merge2 select2 c2 -step delete1: DELETE FROM target WHERE key = 1; -step insert1: INSERT INTO target VALUES (1, 'insert1'); -step c1: COMMIT; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step select2: SELECT * FROM target; -key|val ----+------------------------- - 1|insert1 updated by merge2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete1 insert1 merge2 c1 select2 c2 -step delete1: DELETE FROM target WHERE key = 1; -step insert1: INSERT INTO target VALUES (1, 'insert1'); -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step c1: COMMIT; -step merge2: <... completed> -ERROR: duplicate key value violates unique constraint "target_pkey" -step select2: SELECT * FROM target; -ERROR: current transaction is aborted, commands ignored until end of transaction block -step c2: COMMIT; - -starting permutation: delete1 insert1 merge2i c1 select2 c2 -step delete1: DELETE FROM target WHERE key = 1; -step insert1: INSERT INTO target VALUES (1, 'insert1'); -step merge2i: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN MATCHED THEN UPDATE set val = t.val || ' updated by merge2'; -step c1: COMMIT; -step select2: SELECT * FROM target; -key|val ----+------- - 1|insert1 -(1 row) - -step c2: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/merge-delete.out C:/cirrus/build/testrun/isolation/isolation/results/merge-delete.out --- C:/cirrus/src/test/isolation/expected/merge-delete.out 2024-04-05 16:07:25.321708900 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/merge-delete.out 2024-04-05 16:10:39.151251600 +0000 @@ -1,236 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: delete c1 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step c1: COMMIT; -step select2: SELECT * FROM target; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_pa c1 select2_pa c2 -step delete_pa: DELETE FROM target_pa t WHERE t.key = 1; -step c1: COMMIT; -step select2_pa: SELECT * FROM target_pa; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_tg c1 select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step c1: COMMIT; -step select2_tg: SELECT * FROM target_tg; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete c1 update2 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step c1: COMMIT; -step update2: UPDATE target t SET val = t.val || ' updated by update2' WHERE t.key = 1; -step select2: SELECT * FROM target; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_pa c1 update2_pa select2_pa c2 -step delete_pa: DELETE FROM target_pa t WHERE t.key = 1; -step c1: COMMIT; -step update2_pa: UPDATE target_pa t SET val = t.val || ' updated by update2_pa' WHERE t.key = 1; -step select2_pa: SELECT * FROM target_pa; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_tg c1 update2_tg select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step c1: COMMIT; -step update2_tg: UPDATE target_tg t SET val = t.val || ' updated by update2_tg' WHERE t.key = 1; -step select2_tg: SELECT * FROM target_tg; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete c1 merge2 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step c1: COMMIT; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step select2: SELECT * FROM target; -key|val ----+------ - 1|merge2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete_pa c1 merge2_pa select2_pa c2 -step delete_pa: DELETE FROM target_pa t WHERE t.key = 1; -step c1: COMMIT; -step merge2_pa: MERGE INTO target_pa t USING (SELECT 1 as key, 'merge2_pa' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step select2_pa: SELECT * FROM target_pa; -key|val ----+--------- - 1|merge2_pa -(1 row) - -step c2: COMMIT; - -starting permutation: delete_tg c1 merge2_tg select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step c1: COMMIT; -s2: NOTICE: Insert: (1,merge2_tg) -step merge2_tg: MERGE INTO target_tg t USING (SELECT 1 as key, 'merge2_tg' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step select2_tg: SELECT * FROM target_tg; -key|val ----+--------- - 1|merge2_tg -(1 row) - -step c2: COMMIT; - -starting permutation: delete c1 merge_delete2 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step c1: COMMIT; -step merge_delete2: MERGE INTO target t USING (SELECT 1 as key, 'merge_delete2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN DELETE; -step select2: SELECT * FROM target; -key|val ----+------------- - 1|merge_delete2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete_tg c1 merge_delete2_tg select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step c1: COMMIT; -s2: NOTICE: Insert: (1,merge_delete2_tg) -step merge_delete2_tg: MERGE INTO target_tg t USING (SELECT 1 as key, 'merge_delete2_tg' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN DELETE; -step select2_tg: SELECT * FROM target_tg; -key|val ----+---------------- - 1|merge_delete2_tg -(1 row) - -step c2: COMMIT; - -starting permutation: delete update2 c1 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step update2: UPDATE target t SET val = t.val || ' updated by update2' WHERE t.key = 1; -step c1: COMMIT; -step update2: <... completed> -step select2: SELECT * FROM target; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_pa update2_pa c1 select2_pa c2 -step delete_pa: DELETE FROM target_pa t WHERE t.key = 1; -step update2_pa: UPDATE target_pa t SET val = t.val || ' updated by update2_pa' WHERE t.key = 1; -step c1: COMMIT; -step update2_pa: <... completed> -step select2_pa: SELECT * FROM target_pa; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete_tg update2_tg c1 select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step update2_tg: UPDATE target_tg t SET val = t.val || ' updated by update2_tg' WHERE t.key = 1; -step c1: COMMIT; -step update2_tg: <... completed> -step select2_tg: SELECT * FROM target_tg; -key|val ----+--- -(0 rows) - -step c2: COMMIT; - -starting permutation: delete merge2 c1 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step merge2: MERGE INTO target t USING (SELECT 1 as key, 'merge2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step c1: COMMIT; -step merge2: <... completed> -step select2: SELECT * FROM target; -key|val ----+------ - 1|merge2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete_pa merge2_pa c1 select2_pa c2 -step delete_pa: DELETE FROM target_pa t WHERE t.key = 1; -step merge2_pa: MERGE INTO target_pa t USING (SELECT 1 as key, 'merge2_pa' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step c1: COMMIT; -step merge2_pa: <... completed> -step select2_pa: SELECT * FROM target_pa; -key|val ----+--------- - 1|merge2_pa -(1 row) - -step c2: COMMIT; - -starting permutation: delete_tg merge2_tg c1 select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step merge2_tg: MERGE INTO target_tg t USING (SELECT 1 as key, 'merge2_tg' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; -step c1: COMMIT; -s2: NOTICE: Insert: (1,merge2_tg) -step merge2_tg: <... completed> -step select2_tg: SELECT * FROM target_tg; -key|val ----+--------- - 1|merge2_tg -(1 row) - -step c2: COMMIT; - -starting permutation: delete merge_delete2 c1 select2 c2 -step delete: DELETE FROM target t WHERE t.key = 1; -step merge_delete2: MERGE INTO target t USING (SELECT 1 as key, 'merge_delete2' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN DELETE; -step c1: COMMIT; -step merge_delete2: <... completed> -step select2: SELECT * FROM target; -key|val ----+------------- - 1|merge_delete2 -(1 row) - -step c2: COMMIT; - -starting permutation: delete_tg merge_delete2_tg c1 select2_tg c2 -s1: NOTICE: Delete: (1,setup1) -step delete_tg: DELETE FROM target_tg t WHERE t.key = 1; -step merge_delete2_tg: MERGE INTO target_tg t USING (SELECT 1 as key, 'merge_delete2_tg' as val) s ON s.key = t.key WHEN NOT MATCHED THEN INSERT VALUES (s.key, s.val) WHEN MATCHED THEN DELETE; -step c1: COMMIT; -s2: NOTICE: Insert: (1,merge_delete2_tg) -step merge_delete2_tg: <... completed> -step select2_tg: SELECT * FROM target_tg; -key|val ----+---------------- - 1|merge_delete2_tg -(1 row) - -step c2: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/merge-update.out C:/cirrus/build/testrun/isolation/isolation/results/merge-update.out --- C:/cirrus/src/test/isolation/expected/merge-update.out 2024-04-05 16:07:25.325591100 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/merge-update.out 2024-04-05 16:10:40.404196500 +0000 @@ -1,405 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: merge1 c1 select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step select2: SELECT * FROM target; -key|val ----+------------------------ - 2|setup1 updated by merge1 -(1 row) - -step c2: COMMIT; - -starting permutation: merge1 c1 merge2a select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step merge2a: - MERGE INTO target t - USING (SELECT 1 as key, 'merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by merge2a' - RETURNING merge_action(), t.*; - -merge_action|key|val -------------+---+------------------------------------------------------ -UPDATE | 3|setup1 updated by merge1 source not matched by merge2a -INSERT | 1|merge2a -(2 rows) - -step select2: SELECT * FROM target; -key|val ----+------------------------------------------------------ - 3|setup1 updated by merge1 source not matched by merge2a - 1|merge2a -(2 rows) - -step c2: COMMIT; - -starting permutation: pa_merge1 c1 pa_merge2c_dup a2 -step pa_merge1: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step pa_merge2c_dup: - MERGE INTO pa_target t - USING (VALUES (1), (1)) v(a) - ON t.key = v.a - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by pa_merge2c_dup'; -- should fail - -ERROR: MERGE command cannot affect row a second time -step a2: ABORT; - -starting permutation: merge1 merge2a c1 select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step merge2a: - MERGE INTO target t - USING (SELECT 1 as key, 'merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by merge2a' - RETURNING merge_action(), t.*; - -step c1: COMMIT; -step merge2a: <... completed> -merge_action|key|val -------------+---+------------------------------------------------------ -UPDATE | 3|setup1 updated by merge1 source not matched by merge2a -INSERT | 1|merge2a -(2 rows) - -step select2: SELECT * FROM target; -key|val ----+------------------------------------------------------ - 3|setup1 updated by merge1 source not matched by merge2a - 1|merge2a -(2 rows) - -step c2: COMMIT; - -starting permutation: merge1 merge2a a1 select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step merge2a: - MERGE INTO target t - USING (SELECT 1 as key, 'merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by merge2a' - RETURNING merge_action(), t.*; - -step a1: ABORT; -step merge2a: <... completed> -merge_action|key|val -------------+---+------------------------- -UPDATE | 2|setup1 updated by merge2a -(1 row) - -step select2: SELECT * FROM target; -key|val ----+------------------------- - 2|setup1 updated by merge2a -(1 row) - -step c2: COMMIT; - -starting permutation: merge1 merge2b c1 select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step merge2b: - MERGE INTO target t - USING (SELECT 1 as key, 'merge2b' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED AND t.key < 2 THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step merge2b: <... completed> -step select2: SELECT * FROM target; -key|val ----+------------------------ - 2|setup1 updated by merge1 - 1|merge2b -(2 rows) - -step c2: COMMIT; - -starting permutation: merge1 merge2c c1 select2 c2 -step merge1: - MERGE INTO target t - USING (SELECT 1 as key, 'merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step merge2c: - MERGE INTO target t - USING (SELECT 1 as key, 'merge2c' as val) s - ON s.key = t.key AND t.key < 2 - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step merge2c: <... completed> -step select2: SELECT * FROM target; -key|val ----+------------------------ - 2|setup1 updated by merge1 - 1|merge2c -(2 rows) - -step c2: COMMIT; - -starting permutation: pa_merge1 pa_merge2a c1 pa_select2 c2 -step pa_merge1: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by ' || s.val; - -step pa_merge2a: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by pa_merge2a' - RETURNING merge_action(), t.*; - -step c1: COMMIT; -step pa_merge2a: <... completed> -merge_action|key|val -------------+---+-------------------------------------------------- -UPDATE | 2|initial updated by pa_merge1 updated by pa_merge2a -UPDATE | 3|initial source not matched by pa_merge2a -(2 rows) - -step pa_select2: SELECT * FROM pa_target; -key|val ----+-------------------------------------------------- - 2|initial updated by pa_merge1 updated by pa_merge2a - 3|initial source not matched by pa_merge2a -(2 rows) - -step c2: COMMIT; - -starting permutation: pa_merge2 pa_merge2a c1 pa_select2 c2 -step pa_merge2: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step pa_merge2a: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by pa_merge2a' - RETURNING merge_action(), t.*; - -step c1: COMMIT; -step pa_merge2a: <... completed> -ERROR: tuple to be locked was already moved to another partition due to concurrent update -step pa_select2: SELECT * FROM pa_target; -ERROR: current transaction is aborted, commands ignored until end of transaction block -step c2: COMMIT; - -starting permutation: pa_merge2 c1 pa_merge2a pa_select2 c2 -step pa_merge2: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step pa_merge2a: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2a' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val - WHEN NOT MATCHED BY SOURCE THEN - UPDATE set key = t.key + 1, val = t.val || ' source not matched by pa_merge2a' - RETURNING merge_action(), t.*; - -merge_action|key|val -------------+---+------------------------------------------------------------- -UPDATE | 3|initial source not matched by pa_merge2a -UPDATE | 3|initial updated by pa_merge2 source not matched by pa_merge2a -INSERT | 1|pa_merge2a -(3 rows) - -step pa_select2: SELECT * FROM pa_target; -key|val ----+------------------------------------------------------------- - 1|pa_merge2a - 3|initial source not matched by pa_merge2a - 3|initial updated by pa_merge2 source not matched by pa_merge2a -(3 rows) - -step c2: COMMIT; - -starting permutation: pa_merge3 pa_merge2b_when c1 pa_select2 c2 -step pa_merge3: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set val = 'prefix ' || t.val; - -step pa_merge2b_when: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2b_when' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED AND t.val like 'initial%' THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step pa_merge2b_when: <... completed> -step pa_select2: SELECT * FROM pa_target; -key|val ----+-------------- - 1|prefix initial - 2|initial -(2 rows) - -step c2: COMMIT; - -starting permutation: pa_merge1 pa_merge2b_when c1 pa_select2 c2 -step pa_merge1: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by ' || s.val; - -step pa_merge2b_when: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge2b_when' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED AND t.val like 'initial%' THEN - UPDATE set key = t.key + 1, val = t.val || ' updated by ' || s.val; - -step c1: COMMIT; -step pa_merge2b_when: <... completed> -step pa_select2: SELECT * FROM pa_target; -key|val ----+------------------------------------------------------- - 2|initial - 2|initial updated by pa_merge1 updated by pa_merge2b_when -(2 rows) - -step c2: COMMIT; - -starting permutation: pa_merge1 pa_merge2c_dup c1 a2 -step pa_merge1: - MERGE INTO pa_target t - USING (SELECT 1 as key, 'pa_merge1' as val) s - ON s.key = t.key - WHEN NOT MATCHED THEN - INSERT VALUES (s.key, s.val) - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by ' || s.val; - -step pa_merge2c_dup: - MERGE INTO pa_target t - USING (VALUES (1), (1)) v(a) - ON t.key = v.a - WHEN MATCHED THEN - UPDATE set val = t.val || ' updated by pa_merge2c_dup'; -- should fail - -step c1: COMMIT; -step pa_merge2c_dup: <... completed> -ERROR: MERGE command cannot affect row a second time -step a2: ABORT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/merge-match-recheck.out C:/cirrus/build/testrun/isolation/isolation/results/merge-match-recheck.out --- C:/cirrus/src/test/isolation/expected/merge-match-recheck.out 2024-04-05 16:07:25.322656700 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/merge-match-recheck.out 2024-04-05 16:10:41.047255200 +0000 @@ -1,349 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: update1 merge_status c2 select1 c1 -step update1: UPDATE target t SET balance = balance + 10, val = t.val || ' updated by update1' WHERE t.key = 1; -step merge_status: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -step merge_status: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+------------------------------ - 1| 170|s2 |setup updated by update1 when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update1_tg merge_status_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,170,s1,"setup updated by update1_tg") -step update1_tg: UPDATE target_tg t SET balance = balance + 10, val = t.val || ' updated by update1_tg' WHERE t.key = 1; -step merge_status_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -s1: NOTICE: Update: (1,170,s1,"setup updated by update1_tg") -> (1,170,s2,"setup updated by update1_tg when1") -step merge_status_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+--------------------------------- - 1| 170|s2 |setup updated by update1_tg when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update2 merge_status c2 select1 c1 -step update2: UPDATE target t SET status = 's2', val = t.val || ' updated by update2' WHERE t.key = 1; -step merge_status: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -step merge_status: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+------------------------------ - 1| 160|s3 |setup updated by update2 when2 -(1 row) - -step c1: COMMIT; - -starting permutation: update2_tg merge_status_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,160,s2,"setup updated by update2_tg") -step update2_tg: UPDATE target_tg t SET status = 's2', val = t.val || ' updated by update2_tg' WHERE t.key = 1; -step merge_status_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -s1: NOTICE: Update: (1,160,s2,"setup updated by update2_tg") -> (1,160,s3,"setup updated by update2_tg when2") -step merge_status_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+--------------------------------- - 1| 160|s3 |setup updated by update2_tg when2 -(1 row) - -step c1: COMMIT; - -starting permutation: update3 merge_status c2 select1 c1 -step update3: UPDATE target t SET status = 's3', val = t.val || ' updated by update3' WHERE t.key = 1; -step merge_status: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -step merge_status: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+------------------------------ - 1| 160|s4 |setup updated by update3 when3 -(1 row) - -step c1: COMMIT; - -starting permutation: update3_tg merge_status_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,160,s3,"setup updated by update3_tg") -step update3_tg: UPDATE target_tg t SET status = 's3', val = t.val || ' updated by update3_tg' WHERE t.key = 1; -step merge_status_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -s1: NOTICE: Update: (1,160,s3,"setup updated by update3_tg") -> (1,160,s4,"setup updated by update3_tg when3") -step merge_status_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+--------------------------------- - 1| 160|s4 |setup updated by update3_tg when3 -(1 row) - -step c1: COMMIT; - -starting permutation: update5 merge_status c2 select1 c1 -step update5: UPDATE target t SET status = 's5', val = t.val || ' updated by update5' WHERE t.key = 1; -step merge_status: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -step merge_status: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+------------------------ - 1| 160|s5 |setup updated by update5 -(1 row) - -step c1: COMMIT; - -starting permutation: update5_tg merge_status_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,160,s5,"setup updated by update5_tg") -step update5_tg: UPDATE target_tg t SET status = 's5', val = t.val || ' updated by update5_tg' WHERE t.key = 1; -step merge_status_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND status = 's1' THEN - UPDATE SET status = 's2', val = t.val || ' when1' - WHEN MATCHED AND status = 's2' THEN - UPDATE SET status = 's3', val = t.val || ' when2' - WHEN MATCHED AND status = 's3' THEN - UPDATE SET status = 's4', val = t.val || ' when3'; - -step c2: COMMIT; -step merge_status_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+--------------------------- - 1| 160|s5 |setup updated by update5_tg -(1 row) - -step c1: COMMIT; - -starting permutation: update_bal1 merge_bal c2 select1 c1 -step update_bal1: UPDATE target t SET balance = 50, val = t.val || ' updated by update_bal1' WHERE t.key = 1; -step merge_bal: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - UPDATE SET balance = balance * 4, val = t.val || ' when2' - WHEN MATCHED AND balance < 300 THEN - UPDATE SET balance = balance * 8, val = t.val || ' when3'; - -step c2: COMMIT; -step merge_bal: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+---------------------------------- - 1| 100|s1 |setup updated by update_bal1 when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update_bal1_pa merge_bal_pa c2 select1_pa c1 -step update_bal1_pa: UPDATE target_pa t SET balance = 50, val = t.val || ' updated by update_bal1_pa' WHERE t.key = 1; -step merge_bal_pa: - MERGE INTO target_pa t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - UPDATE SET balance = balance * 4, val = t.val || ' when2' - WHEN MATCHED AND balance < 300 THEN - UPDATE SET balance = balance * 8, val = t.val || ' when3'; - -step c2: COMMIT; -step merge_bal_pa: <... completed> -step select1_pa: SELECT * FROM target_pa; -key|balance|status|val ----+-------+------+------------------------------------- - 1| 100|s1 |setup updated by update_bal1_pa when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update_bal1_tg merge_bal_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,50,s1,"setup updated by update_bal1_tg") -step update_bal1_tg: UPDATE target_tg t SET balance = 50, val = t.val || ' updated by update_bal1_tg' WHERE t.key = 1; -step merge_bal_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - UPDATE SET balance = balance * 4, val = t.val || ' when2' - WHEN MATCHED AND balance < 300 THEN - UPDATE SET balance = balance * 8, val = t.val || ' when3'; - -step c2: COMMIT; -s1: NOTICE: Update: (1,50,s1,"setup updated by update_bal1_tg") -> (1,100,s1,"setup updated by update_bal1_tg when1") -step merge_bal_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+------------------------------------- - 1| 100|s1 |setup updated by update_bal1_tg when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update1 merge_delete c2 select1 c1 -step update1: UPDATE target t SET balance = balance + 10, val = t.val || ' updated by update1' WHERE t.key = 1; -step merge_delete: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - DELETE; - -step c2: COMMIT; -step merge_delete: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+--- -(0 rows) - -step c1: COMMIT; - -starting permutation: update1_tg merge_delete_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,170,s1,"setup updated by update1_tg") -step update1_tg: UPDATE target_tg t SET balance = balance + 10, val = t.val || ' updated by update1_tg' WHERE t.key = 1; -step merge_delete_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - DELETE; - -step c2: COMMIT; -s1: NOTICE: Delete: (1,170,s1,"setup updated by update1_tg") -step merge_delete_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+--- -(0 rows) - -step c1: COMMIT; - -starting permutation: update_bal1 merge_delete c2 select1 c1 -step update_bal1: UPDATE target t SET balance = 50, val = t.val || ' updated by update_bal1' WHERE t.key = 1; -step merge_delete: - MERGE INTO target t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - DELETE; - -step c2: COMMIT; -step merge_delete: <... completed> -step select1: SELECT * FROM target; -key|balance|status|val ----+-------+------+---------------------------------- - 1| 100|s1 |setup updated by update_bal1 when1 -(1 row) - -step c1: COMMIT; - -starting permutation: update_bal1_tg merge_delete_tg c2 select1_tg c1 -s2: NOTICE: Update: (1,160,s1,setup) -> (1,50,s1,"setup updated by update_bal1_tg") -step update_bal1_tg: UPDATE target_tg t SET balance = 50, val = t.val || ' updated by update_bal1_tg' WHERE t.key = 1; -step merge_delete_tg: - MERGE INTO target_tg t - USING (SELECT 1 as key) s - ON s.key = t.key - WHEN MATCHED AND balance < 100 THEN - UPDATE SET balance = balance * 2, val = t.val || ' when1' - WHEN MATCHED AND balance < 200 THEN - DELETE; - -step c2: COMMIT; -s1: NOTICE: Update: (1,50,s1,"setup updated by update_bal1_tg") -> (1,100,s1,"setup updated by update_bal1_tg when1") -step merge_delete_tg: <... completed> -step select1_tg: SELECT * FROM target_tg; -key|balance|status|val ----+-------+------+------------------------------------- - 1| 100|s1 |setup updated by update_bal1_tg when1 -(1 row) - -step c1: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/merge-join.out C:/cirrus/build/testrun/isolation/isolation/results/merge-join.out --- C:/cirrus/src/test/isolation/expected/merge-join.out 2024-04-05 16:07:25.322656700 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/merge-join.out 2024-04-05 16:10:41.580938400 +0000 @@ -1,148 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: b1 m1 s1 c1 b2 m2 s2 c2 -step b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step m1: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step s1: SELECT * FROM tgt; -id|val ---+--- - 1| 10 - 2| 20 - 3| 30 -(3 rows) - -step c1: COMMIT; -step b2: BEGIN ISOLATION LEVEL READ COMMITTED; -step m2: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step s2: SELECT * FROM tgt; -id|val ---+--- - 1| 10 - 2| 20 - 3| 30 -(3 rows) - -step c2: COMMIT; - -starting permutation: b1 b2 m1 hj ex m2 c1 c2 s1 -step b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step b2: BEGIN ISOLATION LEVEL READ COMMITTED; -step m1: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step hj: SET LOCAL enable_mergejoin = off; SET LOCAL enable_nestloop = off; -step ex: EXPLAIN (verbose, costs off) - MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -QUERY PLAN ---------------------------------------------------- -Merge on public.tgt - -> Hash Left Join - Output: tgt.ctid, src.val, src.id, src.ctid - Inner Unique: true - Hash Cond: (src.id = tgt.id) - -> Seq Scan on public.src - Output: src.val, src.id, src.ctid - -> Hash - Output: tgt.ctid, tgt.id - -> Seq Scan on public.tgt - Output: tgt.ctid, tgt.id -(11 rows) - -step m2: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step c1: COMMIT; -step m2: <... completed> -step c2: COMMIT; -step s1: SELECT * FROM tgt; -id|val ---+--- - 1| 10 - 2| 20 - 3| 30 -(3 rows) - - -starting permutation: b1 b2 m1 mj ex m2 c1 c2 s1 -step b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step b2: BEGIN ISOLATION LEVEL READ COMMITTED; -step m1: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step mj: SET LOCAL enable_hashjoin = off; SET LOCAL enable_nestloop = off; -step ex: EXPLAIN (verbose, costs off) - MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -QUERY PLAN ---------------------------------------------------- -Merge on public.tgt - -> Merge Left Join - Output: tgt.ctid, src.val, src.id, src.ctid - Inner Unique: true - Merge Cond: (src.id = tgt.id) - -> Index Scan using src_pkey on public.src - Output: src.val, src.id, src.ctid - -> Index Scan using tgt_pkey on public.tgt - Output: tgt.ctid, tgt.id -(9 rows) - -step m2: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step c1: COMMIT; -step m2: <... completed> -step c2: COMMIT; -step s1: SELECT * FROM tgt; -id|val ---+--- - 1| 10 - 2| 20 - 3| 30 -(3 rows) - - -starting permutation: b1 b2 m1 nl ex m2 c1 c2 s1 -step b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step b2: BEGIN ISOLATION LEVEL READ COMMITTED; -step m1: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step nl: SET LOCAL enable_hashjoin = off; SET LOCAL enable_mergejoin = off; -step ex: EXPLAIN (verbose, costs off) - MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -QUERY PLAN ---------------------------------------------------- -Merge on public.tgt - -> Nested Loop Left Join - Output: tgt.ctid, src.val, src.id, src.ctid - Inner Unique: true - -> Seq Scan on public.src - Output: src.val, src.id, src.ctid - -> Index Scan using tgt_pkey on public.tgt - Output: tgt.ctid, tgt.id - Index Cond: (tgt.id = src.id) -(9 rows) - -step m2: MERGE INTO tgt USING src ON tgt.id = src.id - WHEN MATCHED THEN UPDATE SET val = src.val - WHEN NOT MATCHED THEN INSERT VALUES (src.id, src.val); -step c1: COMMIT; -step m2: <... completed> -step c2: COMMIT; -step s1: SELECT * FROM tgt; -id|val ---+--- - 1| 10 - 2| 20 - 3| 30 -(3 rows) - +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/delete-abort-savept.out C:/cirrus/build/testrun/isolation/isolation/results/delete-abort-savept.out --- C:/cirrus/src/test/isolation/expected/delete-abort-savept.out 2024-04-05 16:07:25.304099200 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/delete-abort-savept.out 2024-04-05 16:10:42.115126700 +0000 @@ -1,139 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1l s1svp s1d s1r s1c s2l s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; -step s2l: SELECT * FROM foo FOR UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s1svp s1d s1r s2l s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s2l: SELECT * FROM foo FOR UPDATE; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s1svp s1d s2l s1r s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s2l: SELECT * FROM foo FOR UPDATE; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s1svp s2l s1d s1r s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s2l: SELECT * FROM foo FOR UPDATE; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s2l s1svp s1d s1r s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2l: SELECT * FROM foo FOR UPDATE; -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s2l s1l s2c s1svp s1d s1r s1c -step s2l: SELECT * FROM foo FOR UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s1l: SELECT * FROM foo FOR KEY SHARE; -step s2c: COMMIT; -step s1l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; - -starting permutation: s2l s2c s1l s1svp s1d s1r s1c -step s2l: SELECT * FROM foo FOR UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: DELETE FROM foo; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/delete-abort-savept-2.out C:/cirrus/build/testrun/isolation/isolation/results/delete-abort-savept-2.out --- C:/cirrus/src/test/isolation/expected/delete-abort-savept-2.out 2024-04-05 16:07:25.303131200 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/delete-abort-savept-2.out 2024-04-05 16:10:42.681522000 +0000 @@ -1,100 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1l s1svp s1d s1r s2l s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: SELECT * FROM foo FOR NO KEY UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s1r: ROLLBACK TO f; -step s2l: SELECT * FROM foo FOR UPDATE; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s1svp s1d s2l s1r s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: SELECT * FROM foo FOR NO KEY UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s2l: SELECT * FROM foo FOR UPDATE; -step s1r: ROLLBACK TO f; -step s1c: COMMIT; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1l s1svp s1d s1r s2l2 s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: SELECT * FROM foo FOR NO KEY UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s1r: ROLLBACK TO f; -step s2l2: SELECT * FROM foo FOR NO KEY UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; - -starting permutation: s1l s1svp s1d s2l2 s1r s1c s2c -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1svp: SAVEPOINT f; -step s1d: SELECT * FROM foo FOR NO KEY UPDATE; -key|value ----+----- - 1| 1 -(1 row) - -step s2l2: SELECT * FROM foo FOR NO KEY UPDATE; -step s1r: ROLLBACK TO f; -step s2l2: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/aborted-keyrevoke.out C:/cirrus/build/testrun/isolation/isolation/results/aborted-keyrevoke.out --- C:/cirrus/src/test/isolation/expected/aborted-keyrevoke.out 2024-04-05 16:07:25.296289600 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/aborted-keyrevoke.out 2024-04-05 16:10:43.135621600 +0000 @@ -1,272 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1s s1u s1r s1l s1c s2l s2c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; - -starting permutation: s1s s1u s1r s1l s2l s1c s2c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; - -starting permutation: s1s s1u s1r s1l s2l s2c s1c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1c: COMMIT; - -starting permutation: s1s s1u s1r s2l s1l s1c s2c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; - -starting permutation: s1s s1u s1r s2l s1l s2c s1c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1c: COMMIT; - -starting permutation: s1s s1u s1r s2l s2c s1l s1c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s1s s1u s2l s1r s1l s1c s2c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s2l: SELECT * FROM foo FOR KEY SHARE; -step s1r: ROLLBACK TO f; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; - -starting permutation: s1s s1u s2l s1r s1l s2c s1c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s2l: SELECT * FROM foo FOR KEY SHARE; -step s1r: ROLLBACK TO f; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1c: COMMIT; - -starting permutation: s1s s1u s2l s1r s2c s1l s1c -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s2l: SELECT * FROM foo FOR KEY SHARE; -step s1r: ROLLBACK TO f; -step s2l: <... completed> -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s1s s2l s1u s2c s1r s1l s1c -step s1s: SAVEPOINT f; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1u: UPDATE foo SET key = 2; -step s2c: COMMIT; -step s1u: <... completed> -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s1s s2l s2c s1u s1r s1l s1c -step s1s: SAVEPOINT f; -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s2l s1s s1u s2c s1r s1l s1c -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s2c: COMMIT; -step s1u: <... completed> -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s2l s1s s2c s1u s1r s1l s1c -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1s: SAVEPOINT f; -step s2c: COMMIT; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; - -starting permutation: s2l s2c s1s s1u s1r s1l s1c -step s2l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s2c: COMMIT; -step s1s: SAVEPOINT f; -step s1u: UPDATE foo SET key = 2; -step s1r: ROLLBACK TO f; -step s1l: SELECT * FROM foo FOR KEY SHARE; -key|value ----+----- - 1| 1 -(1 row) - -step s1c: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/multixact-no-deadlock.out C:/cirrus/build/testrun/isolation/isolation/results/multixact-no-deadlock.out --- C:/cirrus/src/test/isolation/expected/multixact-no-deadlock.out 2024-04-05 16:07:25.327536200 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/multixact-no-deadlock.out 2024-04-05 16:10:45.249886300 +0000 @@ -1,32 +1,3 @@ Parsed test spec with 3 sessions - -starting permutation: s1lock s2lock s1svpt s3lock s1lock2 s2c s1c s3c -step s1lock: SELECT * FROM justthis FOR SHARE; -value ------ - 1 -(1 row) - -step s2lock: SELECT * FROM justthis FOR SHARE; -value ------ - 1 -(1 row) - -step s1svpt: SAVEPOINT foo; -step s3lock: SELECT * FROM justthis FOR UPDATE; -step s1lock2: SELECT * FROM justthis FOR SHARE; -value ------ - 1 -(1 row) - -step s2c: COMMIT; -step s1c: COMMIT; -step s3lock: <... completed> -value ------ - 1 -(1 row) - -step s3c: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/multixact-no-forget_1.out C:/cirrus/build/testrun/isolation/isolation/results/multixact-no-forget.out --- C:/cirrus/src/test/isolation/expected/multixact-no-forget_1.out 2024-04-05 16:07:25.328514800 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/multixact-no-forget.out 2024-04-05 16:10:45.846561000 +0000 @@ -1,160 +1,3 @@ Parsed test spec with 3 sessions - -starting permutation: s1_show s1_commit s2_commit -step s1_show: SELECT current_setting('default_transaction_isolation') <> 'read committed'; -?column? --------- -t -(1 row) - -step s1_commit: COMMIT; -step s2_commit: COMMIT; - -starting permutation: s1_lock s2_update s2_abort s3_forkeyshr s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_abort: ROLLBACK; -step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_lock s2_update s2_commit s3_forkeyshr s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_commit: COMMIT; -step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 2 -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_lock s2_update s1_commit s3_forkeyshr s2_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s1_commit: COMMIT; -step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_commit: COMMIT; - -starting permutation: s1_lock s2_update s2_abort s3_fornokeyupd s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_abort: ROLLBACK; -step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; -value ------ - 1 -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_lock s2_update s2_commit s3_fornokeyupd s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_commit: COMMIT; -step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; -value ------ - 2 -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_lock s2_update s1_commit s3_fornokeyupd s2_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s1_commit: COMMIT; -step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; -step s2_commit: COMMIT; -step s3_fornokeyupd: <... completed> -ERROR: could not serialize access due to concurrent update - -starting permutation: s1_lock s2_update s2_abort s3_forupd s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_abort: ROLLBACK; -step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; -step s1_commit: COMMIT; -step s3_forupd: <... completed> -value ------ - 1 -(1 row) - - -starting permutation: s1_lock s2_update s2_commit s3_forupd s1_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s2_commit: COMMIT; -step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; -step s1_commit: COMMIT; -step s3_forupd: <... completed> -value ------ - 2 -(1 row) - - -starting permutation: s1_lock s2_update s1_commit s3_forupd s2_commit -step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; -value ------ - 1 -(1 row) - -step s2_update: UPDATE dont_forget SET value = 2; -step s1_commit: COMMIT; -step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; -step s2_commit: COMMIT; -step s3_forupd: <... completed> -ERROR: could not serialize access due to concurrent update +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/lock-committed-update.out C:/cirrus/build/testrun/isolation/isolation/results/lock-committed-update.out --- C:/cirrus/src/test/isolation/expected/lock-committed-update.out 2024-04-05 16:07:25.317775400 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/lock-committed-update.out 2024-04-05 16:10:46.504764900 +0000 @@ -1,931 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1b s2b1 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s2l s1ul s1u s1c s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s2l s1ul s1u s1c s1hint s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1ul s1u s1c s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1ul s1u s1c s1hint s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1ul s1u s1c s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1ul s1u s1c s1hint s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(380170116); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; -step s1ul: SELECT pg_advisory_unlock(380170116); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; -id|value ---+----- - 1|one -(1 row) - -step s1c: COMMIT; -step s1hint: SELECT * FROM lcu_table; -id|value ---+----- - 1|two -(1 row) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/lock-committed-keyupdate.out C:/cirrus/build/testrun/isolation/isolation/results/lock-committed-keyupdate.out --- C:/cirrus/src/test/isolation/expected/lock-committed-keyupdate.out 2024-04-05 16:07:25.317775400 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/lock-committed-keyupdate.out 2024-04-05 16:10:47.443735000 +0000 @@ -1,670 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1b s2b1 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1u s1c s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s2l s1c s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s2l s1u s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s2l s1c s1hint s1ul s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - - -starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s1hint s2c -step s1b: BEGIN; -step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1l: SELECT pg_advisory_lock(578902068); -pg_advisory_lock ----------------- - -(1 row) - -step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; -step s1ul: SELECT pg_advisory_unlock(578902068); -pg_advisory_unlock ------------------- -t -(1 row) - -step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; -step s1c: COMMIT; -step s2l: <... completed> -ERROR: could not serialize access due to concurrent update -step s1hint: SELECT * FROM lcku_table; -id|value ---+----- - 1|one - 2|two -(2 rows) - -step s2c: COMMIT; -pg_advisory_unlock_all ----------------------- - -(1 row) - -pg_advisory_unlock_all ----------------------- - -(1 row) - +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/reindex-concurrently-toast.out C:/cirrus/build/testrun/isolation/isolation/results/reindex-concurrently-toast.out --- C:/cirrus/src/test/isolation/expected/reindex-concurrently-toast.out 2024-04-05 16:07:25.344670600 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/reindex-concurrently-toast.out 2024-04-05 16:10:49.904161100 +0000 @@ -233,543 +233,6 @@ ERROR: relation "reind_con_wide" does not exist starting permutation: lsha1 reind2 dro1 end1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step dro1: DROP TABLE reind_con_wide; -step end1: COMMIT; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -ERROR: relation "reind_con_wide" does not exist - -starting permutation: lexc1 ins1 retab2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step end1: COMMIT; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 - 3|3333333333 -(3 rows) - - -starting permutation: lexc1 ins1 reind2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step end1: COMMIT; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 - 3|3333333333 -(3 rows) - - -starting permutation: lexc1 upd1 retab2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step end1: COMMIT; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|4444444444 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 upd1 reind2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step end1: COMMIT; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|4444444444 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 del1 retab2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step end1: COMMIT; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 -(1 row) - - -starting permutation: lexc1 del1 reind2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step end1: COMMIT; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 -(1 row) - - -starting permutation: lexc1 dro1 retab2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step end1: COMMIT; -step retab2: <... completed> -ERROR: relation "pg_toast.reind_con_toast" does not exist -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -ERROR: relation "reind_con_wide" does not exist - -starting permutation: lexc1 dro1 reind2 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step end1: COMMIT; -step reind2: <... completed> -ERROR: relation "pg_toast.reind_con_toast_idx" does not exist -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -ERROR: relation "reind_con_wide" does not exist - -starting permutation: lexc1 retab2 dro1 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step dro1: DROP TABLE reind_con_wide; -step end1: COMMIT; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -ERROR: relation "reind_con_wide" does not exist - -starting permutation: lexc1 reind2 dro1 end1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step dro1: DROP TABLE reind_con_wide; -step end1: COMMIT; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -ERROR: relation "reind_con_wide" does not exist - -starting permutation: lrex1 ins1 retab2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 ins1 reind2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 upd1 retab2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 upd1 reind2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 del1 retab2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 del1 reind2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 dro1 retab2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 dro1 reind2 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 retab2 dro1 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lrex1 reind2 dro1 rol1 sel2 -step lrex1: lock TABLE reind_con_wide in ROW EXCLUSIVE MODE; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 ins1 retab2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 ins1 reind2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 upd1 retab2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 upd1 reind2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 del1 retab2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 del1 reind2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 dro1 retab2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step dro1: DROP TABLE reind_con_wide; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 dro1 reind2 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step dro1: DROP TABLE reind_con_wide; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 retab2 dro1 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lsha1 reind2 dro1 rol1 sel2 -step lsha1: lock TABLE reind_con_wide in SHARE MODE; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 ins1 retab2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 ins1 reind2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step ins1: INSERT INTO reind_con_wide SELECT 3, repeat('3', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i); -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 upd1 retab2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 upd1 reind2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step upd1: UPDATE reind_con_wide SET data = (SELECT repeat('4', 11) || string_agg(g.i::text || random()::text, '') FROM generate_series(1, 500) g(i)) WHERE id = 1; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 del1 retab2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 del1 reind2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step del1: DELETE FROM reind_con_wide WHERE id = 2; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 dro1 retab2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step rol1: ROLLBACK; -step retab2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 dro1 reind2 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step dro1: DROP TABLE reind_con_wide; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step rol1: ROLLBACK; -step reind2: <... completed> -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 retab2 dro1 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step retab2: REINDEX TABLE CONCURRENTLY pg_toast.reind_con_toast; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - - -starting permutation: lexc1 reind2 dro1 rol1 sel2 -step lexc1: lock TABLE reind_con_wide in EXCLUSIVE MODE; -step reind2: REINDEX INDEX CONCURRENTLY pg_toast.reind_con_toast_idx; -step dro1: DROP TABLE reind_con_wide; -step rol1: ROLLBACK; -step sel2: SELECT id, substr(data, 1, 10) FROM reind_con_wide ORDER BY id; -id| substr ---+---------- - 1|1111111111 - 2|2222222222 -(2 rows) - +setup failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request. diff -w -U3 C:/cirrus/src/test/isolation/expected/tuplelock-upgrade-no-deadlock.out C:/cirrus/build/testrun/isolation/isolation/results/tuplelock-upgrade-no-deadlock.out --- C:/cirrus/src/test/isolation/expected/tuplelock-upgrade-no-deadlock.out 2024-04-05 16:07:25.358795200 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/tuplelock-upgrade-no-deadlock.out 2024-04-05 16:10:54.975962000 +0000 @@ -1,253 +1,2 @@ Parsed test spec with 4 sessions - -starting permutation: s1_share s2_for_update s3_share s3_for_update s1_rollback s3_rollback s2_rollback -step s1_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s3_for_update: select id from tlu_job where id = 1 for update; -step s1_rollback: rollback; -step s3_for_update: <... completed> -id --- - 1 -(1 row) - -step s3_rollback: rollback; -step s2_for_update: <... completed> -id --- - 1 -(1 row) - -step s2_rollback: rollback; - -starting permutation: s1_keyshare s2_for_update s3_keyshare s1_update s3_update s1_rollback s3_rollback s2_rollback -step s1_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s1_update: update tlu_job set name = 'b' where id = 1; -step s3_update: update tlu_job set name = 'c' where id = 1; -step s1_rollback: rollback; -step s3_update: <... completed> -step s3_rollback: rollback; -step s2_for_update: <... completed> -id --- - 1 -(1 row) - -step s2_rollback: rollback; - -starting permutation: s1_keyshare s2_for_update s3_keyshare s1_update s3_update s1_commit s3_rollback s2_rollback -step s1_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s1_update: update tlu_job set name = 'b' where id = 1; -step s3_update: update tlu_job set name = 'c' where id = 1; -step s1_commit: commit; -step s3_update: <... completed> -step s3_rollback: rollback; -step s2_for_update: <... completed> -id --- - 1 -(1 row) - -step s2_rollback: rollback; - -starting permutation: s1_keyshare s2_for_update s3_keyshare s3_delete s1_rollback s3_rollback s2_rollback -step s1_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s3_delete: delete from tlu_job where id = 1; -step s1_rollback: rollback; -step s3_delete: <... completed> -step s3_rollback: rollback; -step s2_for_update: <... completed> -id --- - 1 -(1 row) - -step s2_rollback: rollback; - -starting permutation: s1_keyshare s2_for_update s3_keyshare s3_delete s1_rollback s3_commit s2_rollback -step s1_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s3_delete: delete from tlu_job where id = 1; -step s1_rollback: rollback; -step s3_delete: <... completed> -step s3_commit: commit; -step s2_for_update: <... completed> -id --- -(0 rows) - -step s2_rollback: rollback; - -starting permutation: s1_share s2_for_update s3_for_update s1_rollback s2_rollback s3_rollback -step s1_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s2_for_update: select id from tlu_job where id = 1 for update; -step s3_for_update: select id from tlu_job where id = 1 for update; -step s1_rollback: rollback; -step s2_for_update: <... completed> -id --- - 1 -(1 row) - -step s2_rollback: rollback; -step s3_for_update: <... completed> -id --- - 1 -(1 row) - -step s3_rollback: rollback; - -starting permutation: s1_share s2_update s3_update s1_rollback s2_rollback s3_rollback -step s1_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s2_update: update tlu_job set name = 'b' where id = 1; -step s3_update: update tlu_job set name = 'c' where id = 1; -step s1_rollback: rollback; -step s2_update: <... completed> -step s2_rollback: rollback; -step s3_update: <... completed> -step s3_rollback: rollback; - -starting permutation: s1_share s2_delete s3_delete s1_rollback s2_rollback s3_rollback -step s1_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s2_delete: delete from tlu_job where id = 1; -step s3_delete: delete from tlu_job where id = 1; -step s1_rollback: rollback; -step s2_delete: <... completed> -step s2_rollback: rollback; -step s3_delete: <... completed> -step s3_rollback: rollback; - -starting permutation: s1_keyshare s3_for_update s2_for_keyshare s1_savept_e s1_share s1_savept_f s1_fornokeyupd s2_fornokeyupd s0_begin s0_keyshare s1_rollback_f s0_keyshare s1_rollback_e s1_rollback s2_rollback s0_rollback s3_rollback -step s1_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s3_for_update: select id from tlu_job where id = 1 for update; -step s2_for_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s1_savept_e: savepoint s1_e; -step s1_share: select id from tlu_job where id = 1 for share; -id --- - 1 -(1 row) - -step s1_savept_f: savepoint s1_f; -step s1_fornokeyupd: select id from tlu_job where id = 1 for no key update; -id --- - 1 -(1 row) - -step s2_fornokeyupd: select id from tlu_job where id = 1 for no key update; -step s0_begin: begin; -step s0_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s1_rollback_f: rollback to s1_f; -step s0_keyshare: select id from tlu_job where id = 1 for key share; -id --- - 1 -(1 row) - -step s1_rollback_e: rollback to s1_e; -step s2_fornokeyupd: <... completed> -id --- - 1 -(1 row) - -step s1_rollback: rollback; -step s2_rollback: rollback; -step s0_rollback: rollback; -step s3_for_update: <... completed> -id --- - 1 -(1 row) - -step s3_rollback: rollback; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is in recovery mode diff -w -U3 C:/cirrus/src/test/isolation/expected/skip-locked-4_1.out C:/cirrus/build/testrun/isolation/isolation/results/skip-locked-4.out --- C:/cirrus/src/test/isolation/expected/skip-locked-4_1.out 2024-04-05 16:07:25.344670600 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/skip-locked-4.out 2024-04-05 16:11:04.243051100 +0000 @@ -1,23 +1,2 @@ Parsed test spec with 2 sessions - -starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f -step s2a: SELECT pg_advisory_lock(0); -pg_advisory_lock ----------------- - -(1 row) - -step s1a: SELECT * FROM foo WHERE pg_advisory_lock(0) IS NOT NULL ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; -step s2b: UPDATE foo SET data = data WHERE id = 1; -step s2c: BEGIN; -step s2d: UPDATE foo SET data = data WHERE id = 1; -step s2e: SELECT pg_advisory_unlock(0); -pg_advisory_unlock ------------------- -t -(1 row) - -step s1a: <... completed> -ERROR: could not serialize access due to concurrent update -step s1b: COMMIT; -step s2f: COMMIT; +Connection 2 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is in recovery mode diff -w -U3 C:/cirrus/src/test/isolation/expected/alter-table-1.out C:/cirrus/build/testrun/isolation/isolation/results/alter-table-1.out --- C:/cirrus/src/test/isolation/expected/alter-table-1.out 2024-04-05 16:07:25.297262900 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/alter-table-1.out 2024-04-05 16:11:07.199591500 +0000 @@ -1643,1684 +1643,9 @@ step c2: COMMIT; starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx3 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx3 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx3 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx3 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx rx3 at2 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx rx3 at2 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 s2 wx rx3 c2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx3 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx3 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx3 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 rx3 at2 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 rx3 at2 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx s2 rx3 c2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx rx3 s2 at2 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx rx3 s2 at2 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx rx3 s2 c2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 sc1 wx rx3 c2 s2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx3 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx3 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx3 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 rx3 at2 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 rx3 at2 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 s2 rx3 c2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 rx3 s2 at2 sc2 c2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 rx3 s2 at2 c2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 rx3 s2 c2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 at1 wx sc1 rx3 c2 s2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 wx at1 rx3 c2 sc1 s2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 wx rx3 at1 c2 sc1 s2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: s1 rx1 wx rx3 c2 at1 sc1 s2 at2 sc2 -step s1: BEGIN; -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx3 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx3 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step wx: INSERT INTO b VALUES (0); -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx3 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx3 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx3 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx3 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx3 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx rx3 at2 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx rx3 at2 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 s2 wx rx3 c2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx3 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx3 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx3 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 rx3 at2 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 rx3 at2 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx s2 rx3 c2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx rx3 s2 at2 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx rx3 s2 at2 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx rx3 s2 c2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 sc1 wx rx3 c2 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx3 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx3 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx3 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 rx3 at2 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 rx3 at2 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 s2 rx3 c2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step s2: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 rx3 s2 at2 sc2 c2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; -step c2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 rx3 s2 at2 c2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step c2: COMMIT; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 rx3 s2 c2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s2: BEGIN; -step c2: COMMIT; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 at1 wx sc1 rx3 c2 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step wx: INSERT INTO b VALUES (0); -step sc1: COMMIT; -step wx: <... completed> -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 wx at1 rx3 c2 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step wx: INSERT INTO b VALUES (0); -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 wx rx3 at1 c2 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 s1 wx rx3 c2 at1 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step s1: BEGIN; -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx s1 at1 rx3 c2 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx s1 rx3 at1 c2 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step s1: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx s1 rx3 c2 at1 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step s1: BEGIN; -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx rx3 s1 at1 c2 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step c2: COMMIT; -step at1: <... completed> -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx rx3 s1 c2 at1 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step s1: BEGIN; -step c2: COMMIT; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; - -starting permutation: rx1 wx rx3 c2 s1 at1 sc1 s2 at2 sc2 -step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; -a_id ----- - 1 -(1 row) - -step wx: INSERT INTO b VALUES (0); -step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; -a_id ----- - 3 - 3 - 3 -(3 rows) - -step c2: COMMIT; -step s1: BEGIN; -step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step sc1: COMMIT; -step s2: BEGIN; -step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; -step sc2: COMMIT; +s2: WARNING: terminating connection because of crash of another server process +DETAIL: The postmaster has commanded this server process to roll back the current transaction and exit, because another server process exited abnormally and possibly corrupted shared memory. +HINT: In a moment you should be able to reconnect to the database and repeat your command. +setup of session s2 failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request. diff -w -U3 C:/cirrus/src/test/isolation/expected/alter-table-2.out C:/cirrus/build/testrun/isolation/isolation/results/alter-table-2.out --- C:/cirrus/src/test/isolation/expected/alter-table-2.out 2024-04-05 16:07:25.298245300 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/alter-table-2.out 2024-04-05 16:11:07.559947200 +0000 @@ -1,1030 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: s1a s1b s1c s2a s2b s2c s2d s2e s2f -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s1b s2a s1c s2b s2c s2d s2e s2f -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2a: BEGIN; -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s1b s2a s2b s1c s2c s2d s2e s2f -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s1b s2a s2b s2c s1c s2d s2e s2f -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s1b s2a s2b s2c s2d s1c s2e s2f -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s1b s1c s2b s2c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s1b s2b s1c s2c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s1b s2b s2c s1c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s1b s2b s2c s2d s1c s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s1b s1c s2c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s1b s2c s1c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s1b s2c s2d s1c s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s1c s2d s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s2d s1c s2e s2f -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s1a s2a s2b s2c s2d s1b s2e s2f s1c -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s1a s2a s2b s2c s2d s2e s1b s2f s1c -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s1a s2a s2b s2c s2d s2e s2f s1b s1c -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s1a s1b s1c s2b s2c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s1b s2b s1c s2c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s1b s2b s2c s1c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s1b s2b s2c s2d s1c s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s1b s1c s2c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s1b s2c s1c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s1b s2c s2d s1c s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s1c s2d s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s2d s1c s2e s2f -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s1a s2b s2c s2d s1b s2e s2f s1c -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f s1c -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s1a s2b s2c s2d s2e s2f s1b s1c -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s2b s1a s1b s1c s2c s2d s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s1a s1b s2c s1c s2d s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s1a s1b s2c s2d s1c s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s1c s2d s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s2d s1c s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s1a s2c s2d s1b s2e s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s1a s2c s2d s2e s1b s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s1a s2c s2d s2e s2f s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s1c s2d s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s2d s1c s2e s2f -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2d: INSERT INTO b VALUES (0); -step s1c: COMMIT; -step s2d: <... completed> -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; - -starting permutation: s2a s2b s2c s1a s2d s1b s2e s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1a: BEGIN; -step s2d: INSERT INTO b VALUES (0); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s1a s2d s2e s1b s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1a: BEGIN; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s1a s2d s2e s2f s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s1a: BEGIN; -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s1a s1b s2e s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s1a s2e s1b s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1a: BEGIN; -step s2e: INSERT INTO a VALUES (4); -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s1a s2e s2f s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s1a: BEGIN; -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s2e s1a s1b s2f s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s2f: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s2e s1a s2f s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s1a: BEGIN; -step s2f: COMMIT; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s2e s2f s1a s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; -a_id ----- - 3 -(1 row) - -step s2d: INSERT INTO b VALUES (0); -step s2e: INSERT INTO a VALUES (4); -step s2f: COMMIT; -step s1a: BEGIN; -step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; -step s1c: COMMIT; +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/alter-table-3.out C:/cirrus/build/testrun/isolation/isolation/results/alter-table-3.out --- C:/cirrus/src/test/isolation/expected/alter-table-3.out 2024-04-05 16:07:25.298336700 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/alter-table-3.out 2024-04-05 16:11:07.905697500 +0000 @@ -1,785 +1,4 @@ Parsed test spec with 2 sessions starting permutation: s1a s1b s1c s1d s2a s2b s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s1c s2a s1d s2b s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2a: BEGIN; -step s1d: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s1c s2a s2b s1d s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s1c s2a s2b s2c s1d s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s1c s2b s1d s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s1c s2b s2c s1d s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s2b s1c s2c s1d s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s1c s2b s1d s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s1c s2b s2c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s2b s1c s2c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s1b s1c s2c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s1c s2d s1d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2d: COMMIT; -step s1d: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s2d s1c s1d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2d: COMMIT; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s1a s2a s2b s2c s2d s1b s1c s1d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s1a s1b s1c s1d s2b s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s1c s2b s1d s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s1c s2b s2c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s2b s1c s2c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s1b s1c s2c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s1c s2d s1d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2d: COMMIT; -step s1d: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s2d s1c s1d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2d: COMMIT; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s1a s2b s2c s2d s1b s1c s1d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s2b s1a s1b s1c s1d s2c s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s1b s1c s2c s1d s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2c: INSERT INTO a VALUES (0); -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2c: <... completed> -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s1c s2d s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2d: COMMIT; -step s1d: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s2d s1c s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2d: COMMIT; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s2b s1a s2c s2d s1b s1c s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s1c s1d s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; -step s2d: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s1c s2d s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s2d: COMMIT; -step s1d: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s2d s1c s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s2d: COMMIT; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s2b s2c s1a s2d s1b s1c s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s1a: BEGIN; -step s2d: COMMIT; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; - -starting permutation: s2a s2b s2c s2d s1a s1b s1c s1d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: INSERT INTO a VALUES (0); -ERROR: duplicate key value violates unique constraint "a_pkey" -step s2d: COMMIT; -step s1a: BEGIN; -step s1b: ALTER TABLE a DISABLE TRIGGER t; -step s1c: ALTER TABLE a ENABLE TRIGGER t; -step s1d: COMMIT; +setup failed: ERROR: relation "a" already exists diff -w -U3 C:/cirrus/src/test/isolation/expected/create-trigger.out C:/cirrus/build/testrun/isolation/isolation/results/create-trigger.out --- C:/cirrus/src/test/isolation/expected/create-trigger.out 2024-04-05 16:07:25.301185700 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/create-trigger.out 2024-04-05 16:11:08.768446200 +0000 @@ -1,361 +1,4 @@ Parsed test spec with 2 sessions starting permutation: s1a s1b s1c s2a s2b s2c s2d -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s1c s2b s2c s2d -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2a: BEGIN; -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s2b s1c s2c s2d -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s1b s2a s2b s2c s1c s2d -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s1c s2b s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s2b s1c s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s2a s1b s2b s2c s1c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s1b s1c s2c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s1b s2c s1c s2d -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s1a s2a s2b s2c s1b s2d s1c -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2d: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s1a s2a s2b s2c s2d s1b s1c -step s1a: BEGIN; -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; - -starting permutation: s2a s1a s1b s1c s2b s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s2b s1c s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s2a s1a s1b s2b s2c s1c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s1b s1c s2c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s1b s2c s1c s2d -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s2a s1a s2b s2c s1b s2d s1c -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2d: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s1a s2b s2c s2d s1b s1c -step s2a: BEGIN; -step s1a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; - -starting permutation: s2a s2b s1a s1b s1c s2c s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s1b s2c s1c s2d -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1c: COMMIT; -step s2c: <... completed> -step s2d: COMMIT; - -starting permutation: s2a s2b s1a s2c s1b s2d s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2d: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s1a s2c s2d s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s1a: BEGIN; -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s1a s1b s2d s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s2d: COMMIT; -step s1b: <... completed> -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s1a s2d s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s1a: BEGIN; -step s2d: COMMIT; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; - -starting permutation: s2a s2b s2c s2d s1a s1b s1c -step s2a: BEGIN; -step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; -i -- -1 -(1 row) - -step s2c: UPDATE a SET i = 4 WHERE i = 3; -step s2d: COMMIT; -step s1a: BEGIN; -step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); -step s1c: COMMIT; +setup failed: ERROR: relation "a" already exists diff -w -U3 C:/cirrus/src/test/isolation/expected/vacuum-skip-locked.out C:/cirrus/build/testrun/isolation/isolation/results/vacuum-skip-locked.out --- C:/cirrus/src/test/isolation/expected/vacuum-skip-locked.out 2024-04-05 16:07:25.361716900 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/vacuum-skip-locked.out 2024-04-05 16:11:12.670781200 +0000 @@ -1,171 +1,3 @@ Parsed test spec with 2 sessions - -starting permutation: lock_share vac_specified commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_specified: VACUUM (SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_share vac_all_parts commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -step vac_all_parts: VACUUM (SKIP_LOCKED) parted; -step commit: - COMMIT; - - -starting permutation: lock_share analyze_specified commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -s2: WARNING: skipping analyze of "part1" --- lock not available -step analyze_specified: ANALYZE (SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_share analyze_all_parts commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -step analyze_all_parts: ANALYZE (SKIP_LOCKED) parted; -step commit: - COMMIT; - - -starting permutation: lock_share vac_analyze_specified commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_analyze_specified: VACUUM (ANALYZE, SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_share vac_analyze_all_parts commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -step vac_analyze_all_parts: VACUUM (ANALYZE, SKIP_LOCKED) parted; -step commit: - COMMIT; - - -starting permutation: lock_share vac_full_specified commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_full_specified: VACUUM (SKIP_LOCKED, FULL) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_share vac_full_all_parts commit -step lock_share: - BEGIN; - LOCK part1 IN SHARE MODE; - -step vac_full_all_parts: VACUUM (SKIP_LOCKED, FULL) parted; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive vac_specified commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_specified: VACUUM (SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive vac_all_parts commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -step vac_all_parts: VACUUM (SKIP_LOCKED) parted; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive analyze_specified commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -s2: WARNING: skipping analyze of "part1" --- lock not available -step analyze_specified: ANALYZE (SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive analyze_all_parts commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -step analyze_all_parts: ANALYZE (SKIP_LOCKED) parted; -step commit: - COMMIT; - -step analyze_all_parts: <... completed> - -starting permutation: lock_access_exclusive vac_analyze_specified commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_analyze_specified: VACUUM (ANALYZE, SKIP_LOCKED) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive vac_analyze_all_parts commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -step vac_analyze_all_parts: VACUUM (ANALYZE, SKIP_LOCKED) parted; -step commit: - COMMIT; - -step vac_analyze_all_parts: <... completed> - -starting permutation: lock_access_exclusive vac_full_specified commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -s2: WARNING: skipping vacuum of "part1" --- lock not available -step vac_full_specified: VACUUM (SKIP_LOCKED, FULL) part1, part2; -step commit: - COMMIT; - - -starting permutation: lock_access_exclusive vac_full_all_parts commit -step lock_access_exclusive: - BEGIN; - LOCK part1 IN ACCESS EXCLUSIVE MODE; - -step vac_full_all_parts: VACUUM (SKIP_LOCKED, FULL) parted; -step commit: - COMMIT; - +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/stats.out C:/cirrus/build/testrun/isolation/isolation/results/stats.out --- C:/cirrus/src/test/isolation/expected/stats.out 2024-04-05 16:07:25.344670600 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/stats.out 2024-04-05 16:11:14.316285400 +0000 @@ -3096,640 +3096,7 @@ INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); -step s1_listen: LISTEN stats_test_nothing; -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - - -starting permutation: s1_slru_save_stats s1_listen s2_begin s2_big_notify s2_ff s1_slru_check_stats s2_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s2_begin: BEGIN; -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_commit: COMMIT; - -starting permutation: s1_fetch_consistency_none s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s1_commit: COMMIT; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - - -starting permutation: s1_fetch_consistency_cache s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; +PQconsumeInput failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request. -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s1_commit: COMMIT; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - - -starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit s1_slru_check_stats -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s1_commit: COMMIT; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - - -starting permutation: s1_fetch_consistency_none s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_none: SET stats_fetch_consistency = 'none'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s1_clear_snapshot: SELECT pg_stat_clear_snapshot(); -pg_stat_clear_snapshot ----------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_fetch_consistency_cache s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_cache: SET stats_fetch_consistency = 'cache'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s1_clear_snapshot: SELECT pg_stat_clear_snapshot(); -pg_stat_clear_snapshot ----------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_slru_check_stats s2_big_notify s2_ff s1_slru_check_stats s1_clear_snapshot s1_slru_check_stats s1_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s1_clear_snapshot: SELECT pg_stat_clear_snapshot(); -pg_stat_clear_snapshot ----------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s1_func_stats s2_big_notify s2_ff s1_slru_check_stats s1_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s1_func_stats: - SELECT - tso.name, - pg_stat_get_function_calls(tso.oid), - pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero, - pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero - FROM test_stat_oid AS tso - WHERE tso.name = 'test_stat_func' - -name |pg_stat_get_function_calls|total_above_zero|self_above_zero ---------------+--------------------------+----------------+--------------- -test_stat_func| | | -(1 row) - -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -f -(1 row) - -step s1_commit: COMMIT; - -starting permutation: s1_fetch_consistency_snapshot s1_slru_save_stats s1_listen s1_begin s2_big_notify s2_ff s1_slru_check_stats s2_func_call s2_ff s1_func_stats s1_clear_snapshot s1_func_stats s1_commit -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_fetch_consistency_snapshot: SET stats_fetch_consistency = 'snapshot'; -step s1_slru_save_stats: - INSERT INTO test_slru_stats VALUES('notify', 'blks_zeroed', - (SELECT blks_zeroed FROM pg_stat_slru WHERE name = 'notify')); - -step s1_listen: LISTEN stats_test_nothing; -step s1_begin: BEGIN; -step s2_big_notify: SELECT pg_notify('stats_test_use', - repeat(i::text, current_setting('block_size')::int / 2)) FROM generate_series(1, 3) g(i); - -pg_notify ---------- - - - -(3 rows) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_slru_check_stats: - SELECT current.blks_zeroed > before.value - FROM test_slru_stats before - INNER JOIN pg_stat_slru current - ON before.slru = current.name - WHERE before.stat = 'blks_zeroed'; - -?column? --------- -t -(1 row) - -step s2_func_call: SELECT test_stat_func() -test_stat_func --------------- - -(1 row) - -step s2_ff: SELECT pg_stat_force_next_flush(); -pg_stat_force_next_flush ------------------------- - -(1 row) - -step s1_func_stats: - SELECT - tso.name, - pg_stat_get_function_calls(tso.oid), - pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero, - pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero - FROM test_stat_oid AS tso - WHERE tso.name = 'test_stat_func' - -name |pg_stat_get_function_calls|total_above_zero|self_above_zero ---------------+--------------------------+----------------+--------------- -test_stat_func| | | -(1 row) - -step s1_clear_snapshot: SELECT pg_stat_clear_snapshot(); -pg_stat_clear_snapshot ----------------------- - -(1 row) - -step s1_func_stats: - SELECT - tso.name, - pg_stat_get_function_calls(tso.oid), - pg_stat_get_function_total_time(tso.oid) > 0 total_above_zero, - pg_stat_get_function_self_time(tso.oid) > 0 self_above_zero - FROM test_stat_oid AS tso - WHERE tso.name = 'test_stat_func' - -name |pg_stat_get_function_calls|total_above_zero|self_above_zero ---------------+--------------------------+----------------+--------------- -test_stat_func| 1|t |t -(1 row) - -step s1_commit: COMMIT; diff -w -U3 C:/cirrus/src/test/isolation/expected/predicate-gist.out C:/cirrus/build/testrun/isolation/isolation/results/predicate-gist.out --- C:/cirrus/src/test/isolation/expected/predicate-gist.out 2024-04-05 16:07:25.335753300 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/predicate-gist.out 2024-04-05 16:11:17.803594500 +0000 @@ -777,43 +777,9 @@ select g, point(g*500, g*500) from generate_series(12, 18) g; step c1: commit; step c2: commit; +teardown failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request. starting permutation: rxy4 wy4 rxy3 wx3 c2 c1 -step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); - sum ------ -49500 -(1 row) - -step wy4: insert into gist_point_tbl (id, p) - select g, point(g*50, g*50) from generate_series(1, 20) g; -step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); - sum -------- -3202000 -(1 row) - -step wx3: insert into gist_point_tbl (id, p) - select g, point(g*500, g*500) from generate_series(12, 18) g; -step c2: commit; -step c1: commit; - -starting permutation: rxy4 wy4 rxy3 c2 wx3 c1 -step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); - sum ------ -49500 -(1 row) - -step wy4: insert into gist_point_tbl (id, p) - select g, point(g*50, g*50) from generate_series(1, 20) g; -step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); - sum -------- -3202000 -(1 row) - -step c2: commit; -step wx3: insert into gist_point_tbl (id, p) - select g, point(g*500, g*500) from generate_series(12, 18) g; -step c1: commit; +setup failed: no connection to the server diff -w -U3 C:/cirrus/src/test/isolation/expected/partition-concurrent-attach.out C:/cirrus/build/testrun/isolation/isolation/results/partition-concurrent-attach.out --- C:/cirrus/src/test/isolation/expected/partition-concurrent-attach.out 2024-04-05 16:07:25.331461300 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/partition-concurrent-attach.out 2024-04-05 16:11:21.818750600 +0000 @@ -1,55 +1,2 @@ Parsed test spec with 2 sessions - -starting permutation: s1b s1a s2b s2i s1c s2c s2s -step s1b: begin; -step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); -step s2b: begin; -step s2i: insert into tpart values (110,'xxx'), (120, 'yyy'), (150, 'zzz'); -step s1c: commit; -step s2i: <... completed> -ERROR: new row for relation "tpart_default" violates partition constraint -step s2c: commit; -step s2s: select tableoid::regclass, * from tpart; -tableoid| i|j ---------+---+--- -tpart_2 |110|xxx -tpart_2 |120|yyy -tpart_2 |150|zzz -(3 rows) - - -starting permutation: s1b s1a s2b s2i2 s1c s2c s2s -step s1b: begin; -step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); -step s2b: begin; -step s2i2: insert into tpart_default (i, j) values (110, 'xxx'), (120, 'yyy'), (150, 'zzz'); -step s1c: commit; -step s2i2: <... completed> -ERROR: new row for relation "tpart_default" violates partition constraint -step s2c: commit; -step s2s: select tableoid::regclass, * from tpart; -tableoid| i|j ---------+---+--- -tpart_2 |110|xxx -tpart_2 |120|yyy -tpart_2 |150|zzz -(3 rows) - - -starting permutation: s1b s2b s2i s1a s2c s1c s2s -step s1b: begin; -step s2b: begin; -step s2i: insert into tpart values (110,'xxx'), (120, 'yyy'), (150, 'zzz'); -step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); -step s2c: commit; -step s1a: <... completed> -ERROR: updated partition constraint for default partition "tpart_default_default" would be violated by some row -step s1c: commit; -step s2s: select tableoid::regclass, * from tpart; -tableoid | i|j ----------------------+---+--- -tpart_default_default|110|xxx -tpart_default_default|120|yyy -tpart_default_default|150|zzz -(3 rows) - +Connection 2 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is in recovery mode diff -w -U3 C:/cirrus/src/test/isolation/expected/partition-key-update-3.out C:/cirrus/build/testrun/isolation/isolation/results/partition-key-update-3.out --- C:/cirrus/src/test/isolation/expected/partition-key-update-3.out 2024-04-05 16:07:25.333887600 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/partition-key-update-3.out 2024-04-05 16:11:25.859755500 +0000 @@ -1,155 +1,3 @@ Parsed test spec with 3 sessions - -starting permutation: s2beginrr s3beginrr s1u s2donothing s1c s2c s3donothing s3c s2select -step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s2donothing: <... completed> -step s2c: COMMIT; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s3c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2beginrr s3beginrr s1u s3donothing s1c s3c s2donothing s2c s2select -step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s3c: COMMIT; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s2c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2beginrr s3beginrr s1u s2donothing s3donothing s1c s2c s3c s2select -step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s2donothing: <... completed> -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -step s3c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2beginrr s3beginrr s1u s3donothing s2donothing s1c s3c s2c s2select -step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s2donothing: <... completed> -step s3c: COMMIT; -step s2c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2begins s3begins s1u s2donothing s1c s2c s3donothing s3c s2select -step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s2donothing: <... completed> -step s2c: COMMIT; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s3c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2begins s3begins s1u s3donothing s1c s3c s2donothing s2c s2select -step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s3c: COMMIT; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s2c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2begins s3begins s1u s2donothing s3donothing s1c s2c s3c s2select -step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s2donothing: <... completed> -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s2c: COMMIT; -step s3c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - - -starting permutation: s2begins s3begins s1u s3donothing s2donothing s1c s3c s2c s2select -step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; -step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; -step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; -step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; -step s1c: COMMIT; -step s3donothing: <... completed> -ERROR: could not serialize access due to concurrent update -step s2donothing: <... completed> -step s3c: COMMIT; -step s2c: COMMIT; -step s2select: SELECT * FROM foo ORDER BY a; -a|b --+----------------------------------- -1|session-2 donothing -2|initial tuple -> moved by session-1 -(2 rows) - +Connection 0 failed: connection to server on socket "c:/cirrus//.s.PGSQL.40049" failed: FATAL: the database system is not yet accepting connections +DETAIL: Consistent recovery state has not been yet reached. diff -w -U3 C:/cirrus/src/test/isolation/expected/cluster-conflict-partition.out C:/cirrus/build/testrun/isolation/isolation/results/cluster-conflict-partition.out --- C:/cirrus/src/test/isolation/expected/cluster-conflict-partition.out 2024-04-05 16:07:25.300185400 +0000 +++ C:/cirrus/build/testrun/isolation/isolation/results/cluster-conflict-partition.out 2024-04-05 16:11:27.891000600 +0000 @@ -11,25 +11,6 @@ starting permutation: s1_begin s2_auth s1_lock_parent s2_cluster s1_commit s2_reset step s1_begin: BEGIN; -step s2_auth: SET ROLE regress_cluster_part; SET client_min_messages = ERROR; -step s1_lock_parent: LOCK cluster_part_tab IN SHARE UPDATE EXCLUSIVE MODE; -step s2_cluster: CLUSTER cluster_part_tab USING cluster_part_ind; -step s1_commit: COMMIT; -step s2_cluster: <... completed> -step s2_reset: RESET ROLE; - -starting permutation: s1_begin s1_lock_child s2_auth s2_cluster s1_commit s2_reset -step s1_begin: BEGIN; -step s1_lock_child: LOCK cluster_part_tab1 IN SHARE UPDATE EXCLUSIVE MODE; -step s2_auth: SET ROLE regress_cluster_part; SET client_min_messages = ERROR; -step s2_cluster: CLUSTER cluster_part_tab USING cluster_part_ind; -step s1_commit: COMMIT; -step s2_reset: RESET ROLE; - -starting permutation: s1_begin s2_auth s1_lock_child s2_cluster s1_commit s2_reset -step s1_begin: BEGIN; -step s2_auth: SET ROLE regress_cluster_part; SET client_min_messages = ERROR; -step s1_lock_child: LOCK cluster_part_tab1 IN SHARE UPDATE EXCLUSIVE MODE; -step s2_cluster: CLUSTER cluster_part_tab USING cluster_part_ind; -step s1_commit: COMMIT; -step s2_reset: RESET ROLE; +lock wait query failed: server closed the connection unexpectedly + This probably means the server terminated abnormally + before or while processing the request.