rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use annotations to reduce instability of isolation-test results. 

We've long contended with isolation test results that aren't entirely
stable.  Some test scripts insert long delays to try to force stable
results, which is not terribly desirable; but other erratic failure
modes remain, causing unrepeatable buildfarm failures.  I've spent a
fair amount of time trying to solve this by improving the server-side
support code, without much success: that way is fundamentally unable
to cope with diffs that stem from chance ordering of arrival of
messages from different server processes.

We can improve matters on the client side, however, by annotating
the test scripts themselves to show the desired reporting order
of events that might occur in different orders.  This patch adds
three types of annotations to deal with (a) test steps that might or
might not complete their waits before the isolationtester can see them
waiting; (b) test steps in different sessions that can legitimately
complete in either order; and (c) NOTIFY messages that might arrive
before or after the completion of a step in another session.  We might
need more annotation types later, but this seems to be enough to deal
with the instabilities we've seen in the buildfarm.  It also lets us
get rid of all the long delays that were previously used, cutting more
than a minute off the runtime of the isolation tests.

Back-patch to all supported branches, because the buildfarm
instabilities affect all the branches, and because it seems desirable
to keep isolationtester's capabilities the same across all branches
to simplify possible future back-patching of tests.

Discussion: https://postgr.es/m/327948.1623725828@sss.pgh.pa.us
This commit is contained in:
Tom Lane 2021-06-22 21:43:12 -04:00
parent d102aafb62
commit 741d7f1047
49 changed files with 1078 additions and 724 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/test_decoding/expected/concurrent_ddl_dml.out
View File

@ -257,7 +257,7 @@ step s1_insert_tbl2: INSERT INTO tbl2 (val1, val2) VALUES (1, 1);
step s2_alter_tbl1_boolean: ALTER TABLE tbl1 ALTER COLUMN val2 TYPE boolean; <waiting ...>
step s1_commit: COMMIT;
step s2_alter_tbl1_boolean: <... completed>
error in steps s1_commit s2_alter_tbl1_boolean: ERROR: column "val2" cannot be cast automatically to type boolean
ERROR: column "val2" cannot be cast automatically to type boolean
step s2_get_changes: SELECT data FROM pg_logical_slot_get_changes('isolation_slot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');
data

85
src/test/isolation/README
View File

@ -57,11 +57,16 @@ Test specification
==================
Each isolation test is defined by a specification file, stored in the specs
subdirectory. A test specification consists of four parts, in this order:
subdirectory. A test specification defines some SQL "steps", groups them
into "sessions" (where all the steps of one session will be run in the
same backend), and specifies the "permutations" or orderings of the steps
that are to be run.
A test specification consists of four parts, in this order:
setup { <SQL> }
The given SQL block is executed once, in one session only, before running
The given SQL block is executed once (per permutation) before running
the test. Create any test tables or other required objects here. This
part is optional. Multiple setup blocks are allowed if needed; each is
run separately, in the given order. (The reason for allowing multiple
@ -81,8 +86,8 @@ session "<name>"
session is executed in its own connection. A session part consists
of three parts: setup, teardown and one or more "steps". The per-session
setup and teardown parts have the same syntax as the per-test setup and
teardown described above, but they are executed in each session. The
setup part typically contains a "BEGIN" command to begin a transaction.
teardown described above, but they are executed in each session. The setup
part might, for example, contain a "BEGIN" command to begin a transaction.
Each step has the syntax
@ -101,7 +106,8 @@ permutation "<step name>" ...
order). Note that the list of steps in a manually specified
"permutation" line doesn't actually have to be a permutation of the
available steps; it could for instance repeat some steps more than once,
or leave others out.
or leave others out. Also, each step name can be annotated with some
parenthesized markers, which are described below.
Lines beginning with a # are considered comments.
@ -110,7 +116,8 @@ specified in the spec file, or automatically generated), the isolation
tester runs the main setup part, then per-session setup parts, then
the selected session steps, then per-session teardown, then the main
teardown script. Each selected step is sent to the connection associated
with its session.
with its session. The main setup and teardown scripts are run in a
separate "control" session.
Support for blocking commands
@ -129,3 +136,69 @@ tests take a very long time to run, and they serve no useful testing purpose.
Note that isolationtester recognizes that a command has blocked by looking
to see if it is shown as waiting in the pg_locks view; therefore, only
blocks on heavyweight locks will be detected.
Dealing with race conditions
============================
In some cases, the isolationtester's output for a test script may vary
due to timing issues. One way to deal with that is to create variant
expected-files, which follow the usual PG convention that variants for
foo.spec are named foo_1.out, foo_2.out, etc. However, this method is
discouraged since the extra files are a nuisance for maintenance.
Instead, it's usually possible to stabilize the test output by applying
special markers to some of the step names listed in a permutation line.
The general form of a permutation entry is
<step name> [ ( <marker> [ , <marker> ... ] ) ]
where each marker defines a "blocking condition". The step will not be
reported as completed before all the blocking conditions are satisfied.
The possible markers are:
*
<other step name>
<other step name> notices <n>
An asterisk marker, such as mystep(*), forces the isolationtester to
report the step as "waiting" as soon as it's been launched, regardless of
whether it would have been detected as waiting later. This is useful for
stabilizing cases that are sometimes reported as waiting and other times
reported as immediately completing, depending on the relative speeds of
the step and the isolationtester's status-monitoring queries.
A marker consisting solely of a step name indicates that this step may
not be reported as completing until that other step has completed.
This allows stabilizing cases where two queries might be seen to complete
in either order. Note that this step can be *launched* before the other
step has completed. (If the other step is used more than once in the
current permutation, this step cannot complete while any of those
instances is active.)
A marker of the form "<other step name> notices <n>" (where <n> is a
positive integer) indicates that this step may not be reported as
completing until the other step's session has returned at least <n>
NOTICE messages, counting from when this step is launched. This is useful
for stabilizing cases where a step can return NOTICE messages before it
actually completes, and those messages must be synchronized with the
completions of other steps.
Notice that these markers can only delay reporting of the completion
of a step, not the launch of a step. The isolationtester will launch
the next step in a permutation as soon as (A) all prior steps of the
same session are done, and (B) the immediately preceding step in the
permutation is done or deemed blocked. For this purpose, "deemed
blocked" means that it has been seen to be waiting on a database lock,
or that it is complete but the report of its completion is delayed by
one of these markers.
In some cases it is important not to launch a step until after the
completion of a step in another session that could have been deemed
blocked. An example is that if step s1 in session A is issuing a
cancel for step s2 in session B, we'd better not launch B's next step
till we're sure s1 is done. If s1 is blockable, trouble could ensue.
The best way to prevent that is to create an empty step in session A
and run it, without any markers, just before the next session B step.
The empty step cannot be launched until s1 is done, and in turn the
next session B step cannot be launched until the empty step finishes.

32
src/test/isolation/expected/alter-table-3.out
View File

@ -54,7 +54,7 @@ i
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d
@ -97,7 +97,7 @@ i
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d
@ -126,7 +126,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d
@ -141,7 +141,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d
@ -184,7 +184,7 @@ i
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d
@ -213,7 +213,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d
@ -228,7 +228,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d
@ -257,7 +257,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d
@ -272,7 +272,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d
@ -371,7 +371,7 @@ i
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d
@ -400,7 +400,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d
@ -415,7 +415,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d
@ -444,7 +444,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d
@ -459,7 +459,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d
@ -544,7 +544,7 @@ step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d
@ -559,7 +559,7 @@ step s2c: INSERT INTO a VALUES (0); <waiting ...>
step s1c: ALTER TABLE a ENABLE TRIGGER t;
step s1d: COMMIT;
step s2c: <... completed>
error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
ERROR: duplicate key value violates unique constraint "a_pkey"
step s2d: COMMIT;
starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d

2
src/test/isolation/expected/alter-table-4.out
View File

@ -50,7 +50,7 @@ step s1modc1a: ALTER TABLE c1 ALTER COLUMN a TYPE float;
step s2sel: SELECT SUM(a) FROM p; <waiting ...>
step s1c: COMMIT;
step s2sel: <... completed>
error in steps s1c s2sel: ERROR: attribute "a" of relation "c1" does not match parent's type
ERROR: attribute "a" of relation "c1" does not match parent's type
step s2sel: SELECT SUM(a) FROM p;
sum

2
src/test/isolation/expected/deadlock-hard.out
View File

@ -18,8 +18,8 @@ step s6a7: LOCK TABLE a7; <waiting ...>
step s7a8: LOCK TABLE a8; <waiting ...>
step s8a1: LOCK TABLE a1; <waiting ...>
step s8a1: <... completed>
ERROR: deadlock detected
step s7a8: <... completed>
error in steps s8a1 s7a8: ERROR: deadlock detected
step s8c: COMMIT;
step s7c: COMMIT;
step s6a7: <... completed>

2
src/test/isolation/expected/deadlock-simple.out
View File

@ -5,7 +5,7 @@ step s1as: LOCK TABLE a1 IN ACCESS SHARE MODE;
step s2as: LOCK TABLE a1 IN ACCESS SHARE MODE;
step s1ae: LOCK TABLE a1 IN ACCESS EXCLUSIVE MODE; <waiting ...>
step s2ae: LOCK TABLE a1 IN ACCESS EXCLUSIVE MODE;
ERROR: deadlock detected
step s1ae: <... completed>
error in steps s2ae s1ae: ERROR: deadlock detected
step s1c: COMMIT;
step s2c: COMMIT;

200
src/test/isolation/expected/detach-partition-concurrently-3.out
View File

@ -1,6 +1,6 @@
Parsed test spec with 2 sessions
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1describe s1alter
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1describe s1alter
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -8,13 +8,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1describe: SELECT 'd3_listp' AS root, * FROM pg_partition_tree('d3_listp')
UNION ALL SELECT 'd3_listp1', * FROM pg_partition_tree('d3_listp1');
@ -26,7 +25,7 @@ d3_listp1 d3_listp1 t 0
step s1alter: ALTER TABLE d3_listp1 ALTER a DROP NOT NULL;
ERROR: cannot alter partition "d3_listp1" with an incomplete detach
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1insert s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1insert s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -34,18 +33,17 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1insert: INSERT INTO d3_listp VALUES (1);
ERROR: no partition of relation "d3_listp" found for row
step s1c: COMMIT;
starting permutation: s2snitch s1brr s1s s2detach s1cancel s2noop s1insert s1c s1spart
starting permutation: s2snitch s1brr s1s s2detach s1cancel s1insert s1c s1spart
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
step s1s: SELECT * FROM d3_listp;
@ -53,13 +51,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1insert: INSERT INTO d3_listp VALUES (1);
step s1c: COMMIT;
step s1spart: SELECT * FROM d3_listp1;
@ -68,7 +65,7 @@ a
1
1
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1insertpart
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1insertpart
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -76,17 +73,16 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1insertpart: INSERT INTO d3_listp1 VALUES (1);
starting permutation: s2snitch s1b s1s s2detach2 s1cancel s2noop s1c s1brr s1insert s1s s1insert s1c
starting permutation: s2snitch s1b s1s s2detach2 s1cancel s1c s1brr s1insert s1s s1insert s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -94,13 +90,12 @@ a
1
step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach2: <... completed>
error in steps s1cancel s2detach2: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
step s1insert: INSERT INTO d3_listp VALUES (1);
@ -112,7 +107,7 @@ a
step s1insert: INSERT INTO d3_listp VALUES (1);
step s1c: COMMIT;
starting permutation: s2snitch s1b s1s s2detach2 s1cancel s2noop s1c s1brr s1s s1insert s1s s1c
starting permutation: s2snitch s1b s1s s2detach2 s1cancel s1c s1brr s1s s1insert s1s s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -120,13 +115,12 @@ a
1
step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach2: <... completed>
error in steps s1cancel s2detach2: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1brr: BEGIN ISOLATION LEVEL REPEATABLE READ;
step s1s: SELECT * FROM d3_listp;
@ -141,7 +135,7 @@ a
1
step s1c: COMMIT;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1drop s1list
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1drop s1list
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -149,13 +143,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1drop: DROP TABLE d3_listp;
step s1list: SELECT relname FROM pg_catalog.pg_class
@ -163,7 +156,7 @@ step s1list: SELECT relname FROM pg_catalog.pg_class
relname
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1trunc s1spart
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1trunc s1spart
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -171,13 +164,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1trunc: TRUNCATE TABLE d3_listp;
step s1spart: SELECT * FROM d3_listp1;
@ -185,7 +177,7 @@ a
1
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s2detach2 s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1noop s2detach2 s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -193,18 +185,18 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1noop:
step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
ERROR: partition "d3_listp1" already pending detach in partitioned table "public.d3_listp"
step s1c: COMMIT;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s2detachfinal s1c s2detach2
starting permutation: s2snitch s1b s1s s2detach s1cancel s1noop s2detachfinal s1c s2detach2
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -212,19 +204,19 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1noop:
step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <waiting ...>
step s1c: COMMIT;
step s2detachfinal: <... completed>
step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1droppart s2detach2
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1droppart s2detach2
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -232,18 +224,17 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1droppart: DROP TABLE d3_listp1;
step s2detach2: ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2drop s1s s2commit
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2drop s1s s2commit
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -251,13 +242,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s2begin: BEGIN;
step s2drop: DROP TABLE d3_listp1;
@ -267,7 +257,7 @@ step s1s: <... completed>
a
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1spart s2detachfinal s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1spart s2detachfinal s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -275,13 +265,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1b: BEGIN;
step s1spart: SELECT * FROM d3_listp1;
@ -292,7 +281,7 @@ step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <w
step s1c: COMMIT;
step s2detachfinal: <... completed>
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1s s2detachfinal s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1s s2detachfinal s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -300,13 +289,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -315,7 +303,7 @@ a
step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
step s1c: COMMIT;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s1b s1spart s2detachfinal s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s1b s1spart s2detachfinal s1c
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -323,13 +311,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s1b: BEGIN;
step s1spart: SELECT * FROM d3_listp1;
@ -340,7 +327,7 @@ step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; <w
step s1c: COMMIT;
step s2detachfinal: <... completed>
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s2commit
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s2commit
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -348,19 +335,18 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s2begin: BEGIN;
step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
step s2commit: COMMIT;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s1spart s2commit
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s1spart s2commit
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -368,13 +354,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s2begin: BEGIN;
step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;
@ -385,7 +370,7 @@ a
1
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1c s2begin s2detachfinal s1insertpart s2commit
starting permutation: s2snitch s1b s1s s2detach s1cancel s1c s2begin s2detachfinal s1insertpart s2commit
step s2snitch: INSERT INTO d3_pid SELECT pg_backend_pid();
step s1b: BEGIN;
step s1s: SELECT * FROM d3_listp;
@ -393,13 +378,12 @@ a
1
step s2detach: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; <waiting ...>
step s1cancel: SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid;
pg_cancel_backendpg_sleep
step s1cancel: SELECT pg_cancel_backend(pid) FROM d3_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: COMMIT;
step s2begin: BEGIN;
step s2detachfinal: ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE;

118
src/test/isolation/expected/detach-partition-concurrently-4.out
View File

@ -1,6 +1,6 @@
Parsed test spec with 3 sessions
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s1insert s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s1s: select * from d4_primary;
@ -9,13 +9,12 @@ a
1
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
@ -30,11 +29,11 @@ a
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s2detach: <... completed>
error in steps s1insert s2detach: ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1brr s1s s2detach s1cancel s2noop s1insert s1c
starting permutation: s2snitch s1brr s1s s2detach s1cancel s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1brr: begin isolation level repeatable read;
step s1s: select * from d4_primary;
@ -43,13 +42,12 @@ a
1
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
@ -64,22 +62,21 @@ a
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s2detach: <... completed>
error in steps s1insert s2detach: ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1b s1declare s2detach s1cancel s2noop s1fetchall s1insert s1c
starting permutation: s2snitch s1b s1declare s2detach s1cancel s1fetchall s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s1declare: declare f cursor for select * from d4_primary;
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1fetchall: fetch all from f;
a
@ -100,22 +97,21 @@ a
1
2
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s2detach: <... completed>
error in steps s1insert s2detach: ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1b s1declare s2detach s1cancel s2noop s1svpt s1insert s1rollback s1fetchall s1c
starting permutation: s2snitch s1b s1declare s2detach s1cancel s1svpt s1insert s1rollback s1fetchall s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s1declare: declare f cursor for select * from d4_primary;
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1svpt: savepoint f;
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
@ -144,16 +140,15 @@ a
step s1c: commit;
step s2detach: <... completed>
starting permutation: s2snitch s1b s2detach s1declare s1cancel s2noop s1fetchall s1insert s1c
starting permutation: s2snitch s1b s2detach s1declare s1cancel s1fetchall s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently;
step s1declare: declare f cursor for select * from d4_primary;
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
step s2noop: UNLISTEN noop;
t
step s1fetchall: fetch all from f;
a
@ -175,16 +170,15 @@ step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1b s2detach s1declare s1cancel s2noop s1svpt s1insert s1rollback s1fetchall s1c
starting permutation: s2snitch s1b s2detach s1declare s1cancel s1svpt s1insert s1rollback s1fetchall s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently;
step s1declare: declare f cursor for select * from d4_primary;
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
step s2noop: UNLISTEN noop;
t
step s1svpt: savepoint f;
step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
@ -210,7 +204,7 @@ a
2
step s1c: commit;
starting permutation: s2snitch s1brr s1declare2 s1fetchone s2detach s1cancel s2noop s1updcur s1c
starting permutation: s2snitch s1brr s1declare2 s1fetchone s2detach s1cancel s1updcur s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1brr: begin isolation level repeatable read;
step s1declare2: declare f cursor for select * from d4_fk where a = 2;
@ -219,13 +213,12 @@ a
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1updcur: update d4_fk set a = 1 where current of f;
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
@ -240,8 +233,8 @@ a
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1updcur: update d4_fk set a = 1 where current of f;
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s2detach: <... completed>
error in steps s1updcur s2detach: ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1brr s1declare2 s1fetchone s1updcur s2detach s1c
@ -256,7 +249,7 @@ step s1updcur: update d4_fk set a = 1 where current of f;
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1c: commit;
step s2detach: <... completed>
error in steps s1c s2detach: ERROR: removing partition "d4_primary1" violates foreign key constraint "d4_fk_a_fkey1"
ERROR: removing partition "d4_primary1" violates foreign key constraint "d4_fk_a_fkey1"
starting permutation: s2snitch s1b s1s s2detach s3insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
@ -272,7 +265,7 @@ ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk
step s1c: commit;
step s2detach: <... completed>
starting permutation: s2snitch s1b s1s s2detach s3brr s3insert s3commit s1cancel s2noop s1c
starting permutation: s2snitch s1b s1s s2detach s3brr s3insert s3commit s1cancel s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s1s: select * from d4_primary;
@ -285,13 +278,12 @@ step s3brr: begin isolation level repeatable read;
step s3insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s3commit: commit;
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1c: commit;
starting permutation: s2snitch s1b s1s s2detach s3brr s3insert s3commit s1c
@ -310,7 +302,7 @@ step s3commit: commit;
step s1c: commit;
step s2detach: <... completed>
starting permutation: s2snitch s1brr s1s s2detach s1cancel s2noop s3vacfreeze s1s s1insert s1c
starting permutation: s2snitch s1brr s1s s2detach s1cancel s1noop s3vacfreeze s1s s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1brr: begin isolation level repeatable read;
step s1s: select * from d4_primary;
@ -319,13 +311,13 @@ a
1
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1noop:
step s3vacfreeze: vacuum freeze pg_catalog.pg_inherits;
step s1s: select * from d4_primary;
a
@ -336,7 +328,7 @@ step s1insert: insert into d4_fk values (1);
ERROR: insert or update on table "d4_fk" violates foreign key constraint "d4_fk_a_fkey"
step s1c: commit;
starting permutation: s2snitch s1b s1s s2detach s1cancel s2noop s3vacfreeze s1s s1insert s1c
starting permutation: s2snitch s1b s1s s2detach s1cancel s1noop s3vacfreeze s1s s1insert s1c
step s2snitch: insert into d4_pid select pg_backend_pid();
step s1b: begin;
step s1s: select * from d4_primary;
@ -345,13 +337,13 @@ a
1
2
step s2detach: alter table d4_primary detach partition d4_primary1 concurrently; <waiting ...>
step s1cancel: select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid;
pg_cancel_backendpg_sleep
step s1cancel: select pg_cancel_backend(pid) from d4_pid;
pg_cancel_backend
t
t
step s2detach: <... completed>
error in steps s1cancel s2detach: ERROR: canceling statement due to user request
step s2noop: UNLISTEN noop;
ERROR: canceling statement due to user request
step s1noop:
step s3vacfreeze: vacuum freeze pg_catalog.pg_inherits;
step s1s: select * from d4_primary;
a

18
src/test/isolation/expected/eval-plan-qual-trigger.out
View File

@ -1,3 +1,9 @@
unused step name: s2_r
unused step name: s3_b_rc
unused step name: s3_c
unused step name: s3_del_a
unused step name: s3_r
unused step name: s3_upd_a_data
Parsed test spec with 4 sessions
starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s1_c s2_upd_a_data s2_c s0_rep
@ -609,7 +615,7 @@ s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <N
step s2_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s2') RETURNING *; <waiting ...>
step s1_c: COMMIT;
step s2_ins_a: <... completed>
error in steps s1_c s2_ins_a: ERROR: duplicate key value violates unique constraint "trigtest_pkey"
ERROR: duplicate key value violates unique constraint "trigtest_pkey"
step s2_c: COMMIT;
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
key data
@ -2023,7 +2029,7 @@ step s2_upd_a_data:
<waiting ...>
step s1_c: COMMIT;
step s2_upd_a_data: <... completed>
error in steps s1_c s2_upd_a_data: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2_c: COMMIT;
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
key data
@ -2136,7 +2142,7 @@ step s2_upd_a_data:
<waiting ...>
step s1_c: COMMIT;
step s2_upd_a_data: <... completed>
error in steps s1_c s2_upd_a_data: ERROR: could not serialize access due to concurrent delete
ERROR: could not serialize access due to concurrent delete
step s2_c: COMMIT;
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
key data
@ -2202,9 +2208,3 @@ key data
key-a val-a-s1-ups2
key-b val-b-s1
unused step name: s2_r
unused step name: s3_b_rc
unused step name: s3_c
unused step name: s3_del_a
unused step name: s3_r
unused step name: s3_upd_a_data

6
src/test/isolation/expected/eval-plan-qual.out
View File

@ -551,7 +551,7 @@ balance
step updwctefail: WITH doup AS (UPDATE accounts SET balance = balance + 1100 WHERE accountid = 'checking' RETURNING *, update_checking(999)) UPDATE accounts a SET balance = doup.balance + 100 FROM doup RETURNING *; <waiting ...>
step c1: COMMIT;
step updwctefail: <... completed>
error in steps c1 updwctefail: ERROR: tuple to be updated was already modified by an operation triggered by the current command
ERROR: tuple to be updated was already modified by an operation triggered by the current command
step c2: COMMIT;
step read: SELECT * FROM accounts ORDER BY accountid;
accountid balance
@ -584,7 +584,7 @@ balance
step delwctefail: WITH doup AS (UPDATE accounts SET balance = balance + 1100 WHERE accountid = 'checking' RETURNING *, update_checking(999)) DELETE FROM accounts a USING doup RETURNING *; <waiting ...>
step c1: COMMIT;
step delwctefail: <... completed>
error in steps c1 delwctefail: ERROR: tuple to be deleted was already modified by an operation triggered by the current command
ERROR: tuple to be deleted was already modified by an operation triggered by the current command
step c2: COMMIT;
step read: SELECT * FROM accounts ORDER BY accountid;
accountid balance
@ -931,7 +931,7 @@ step complexpartupdate_route_err1:
<waiting ...>
step c1: COMMIT;
step complexpartupdate_route_err1: <... completed>
error in steps c1 complexpartupdate_route_err1: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step c2: COMMIT;
starting permutation: simplepartupdate_noroute complexpartupdate_route c1 c2

12
src/test/isolation/expected/fk-deadlock2_1.out
View File

@ -14,7 +14,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s1c: COMMIT;
step s2u1: <... completed>
error in steps s1c s2u1: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
ERROR: current transaction is aborted, commands ignored until end of transaction block
step s2c: COMMIT;
@ -26,7 +26,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s1u1 s2u1 s2u2 s1u2 s2c s1c
@ -36,7 +36,7 @@ step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s1u1 s2u1 s2u2 s2c s1u2 s1c
@ -55,7 +55,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s1u1 s2u2 s1u2 s2c s1c
@ -65,7 +65,7 @@ step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s1u1 s2u2 s2c s1u2 s1c
@ -84,7 +84,7 @@ step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s2u2 s1u1 s2c s1u2 s1c

12
src/test/isolation/expected/fk-deadlock2_2.out
View File

@ -14,7 +14,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s1c: COMMIT;
step s2u1: <... completed>
error in steps s1c s2u1: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
ERROR: current transaction is aborted, commands ignored until end of transaction block
step s2c: COMMIT;
@ -26,7 +26,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s1u1 s2u1 s2u2 s1u2 s2c s1c
@ -36,7 +36,7 @@ step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s1u1 s2u1 s2u2 s2c s1u2 s1c
@ -55,7 +55,7 @@ step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s1u1 s2u2 s1u2 s2c s1c
@ -65,7 +65,7 @@ step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s1u1 s2u2 s2c s1u2 s1c
@ -84,7 +84,7 @@ step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1;
step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2u1 s2u2 s1u1 s2c s1u2 s1c

12
src/test/isolation/expected/fk-deadlock_1.out
View File

@ -24,7 +24,7 @@ step s2i: INSERT INTO child VALUES (2, 1);
step s2u: UPDATE parent SET aux = 'baz'; <waiting ...>
step s1c: COMMIT;
step s2u: <... completed>
error in steps s1c s2u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
starting permutation: s1i s2i s1u s1c s2u s2c
@ -43,7 +43,7 @@ step s1u: UPDATE parent SET aux = 'bar';
step s2u: UPDATE parent SET aux = 'baz'; <waiting ...>
step s1c: COMMIT;
step s2u: <... completed>
error in steps s1c s2u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
starting permutation: s1i s2i s2u s1u s2c s1c
@ -53,7 +53,7 @@ step s2u: UPDATE parent SET aux = 'baz';
step s1u: UPDATE parent SET aux = 'bar'; <waiting ...>
step s2c: COMMIT;
step s1u: <... completed>
error in steps s2c s1u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s1i s2i s2u s2c s1u s1c
@ -81,7 +81,7 @@ step s1u: UPDATE parent SET aux = 'bar';
step s2u: UPDATE parent SET aux = 'baz'; <waiting ...>
step s1c: COMMIT;
step s2u: <... completed>
error in steps s1c s2u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
starting permutation: s2i s1i s2u s1u s2c s1c
@ -91,7 +91,7 @@ step s2u: UPDATE parent SET aux = 'baz';
step s1u: UPDATE parent SET aux = 'bar'; <waiting ...>
step s2c: COMMIT;
step s1u: <... completed>
error in steps s2c s1u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2i s1i s2u s2c s1u s1c
@ -110,7 +110,7 @@ step s1i: INSERT INTO child VALUES (1, 1);
step s1u: UPDATE parent SET aux = 'bar'; <waiting ...>
step s2c: COMMIT;
step s1u: <... completed>
error in steps s2c s1u: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1c: COMMIT;
starting permutation: s2i s2u s1i s2c s1u s1c

12
src/test/isolation/expected/fk-partitioned-1.out
View File

@ -25,7 +25,7 @@ step s2b: begin;
step s2a: alter table pfk attach partition pfk1 for values in (1); <waiting ...>
step s1c: commit;
step s2a: <... completed>
error in steps s1c s2a: ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
step s2c: commit;
starting permutation: s1b s2b s1d s1c s2a s2c
@ -44,7 +44,7 @@ step s1d: delete from ppk1 where a = 1;
step s2a: alter table pfk attach partition pfk1 for values in (1); <waiting ...>
step s1c: commit;
step s2a: <... completed>
error in steps s1c s2a: ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
step s2c: commit;
starting permutation: s1b s2b s2a s1d s2c s1c
@ -54,7 +54,7 @@ step s2a: alter table pfk attach partition pfk1 for values in (1);
step s1d: delete from ppk1 where a = 1; <waiting ...>
step s2c: commit;
step s1d: <... completed>
error in steps s2c s1d: ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
step s1c: commit;
starting permutation: s1b s2b s2a s2c s1d s1c
@ -82,7 +82,7 @@ step s1d: delete from ppk1 where a = 1;
step s2a: alter table pfk attach partition pfk1 for values in (1); <waiting ...>
step s1c: commit;
step s2a: <... completed>
error in steps s1c s2a: ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
step s2c: commit;
starting permutation: s2b s1b s2a s1d s2c s1c
@ -92,7 +92,7 @@ step s2a: alter table pfk attach partition pfk1 for values in (1);
step s1d: delete from ppk1 where a = 1; <waiting ...>
step s2c: commit;
step s1d: <... completed>
error in steps s2c s1d: ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
step s1c: commit;
starting permutation: s2b s1b s2a s2c s1d s1c
@ -111,7 +111,7 @@ step s1b: begin;
step s1d: delete from ppk1 where a = 1; <waiting ...>
step s2c: commit;
step s1d: <... completed>
error in steps s2c s1d: ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
step s1c: commit;
starting permutation: s2b s2a s1b s2c s1d s1c

12
src/test/isolation/expected/fk-partitioned-2.out
View File

@ -7,7 +7,7 @@ step s2b: begin;
step s2i: insert into pfk values (1); <waiting ...>
step s1c: commit;
step s2i: <... completed>
error in steps s1c s2i: ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
step s2c: commit;
starting permutation: s1b s1d s2bs s2i s1c s2c
@ -20,7 +20,7 @@ step s2bs: begin isolation level serializable; select 1;
step s2i: insert into pfk values (1); <waiting ...>
step s1c: commit;
step s2i: <... completed>
error in steps s1c s2i: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: commit;
starting permutation: s1b s2b s1d s2i s1c s2c
@ -30,7 +30,7 @@ step s1d: delete from ppk where a = 1;
step s2i: insert into pfk values (1); <waiting ...>
step s1c: commit;
step s2i: <... completed>
error in steps s1c s2i: ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey"
step s2c: commit;
starting permutation: s1b s2bs s1d s2i s1c s2c
@ -43,7 +43,7 @@ step s1d: delete from ppk where a = 1;
step s2i: insert into pfk values (1); <waiting ...>
step s1c: commit;
step s2i: <... completed>
error in steps s1c s2i: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: commit;
starting permutation: s1b s2b s2i s1d s2c s1c
@ -53,7 +53,7 @@ step s2i: insert into pfk values (1);
step s1d: delete from ppk where a = 1; <waiting ...>
step s2c: commit;
step s1d: <... completed>
error in steps s2c s1d: ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
step s1c: commit;
starting permutation: s1b s2bs s2i s1d s2c s1c
@ -66,5 +66,5 @@ step s2i: insert into pfk values (1);
step s1d: delete from ppk where a = 1; <waiting ...>
step s2c: commit;
step s1d: <... completed>
error in steps s2c s1d: ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk"
step s1c: commit;

8
src/test/isolation/expected/insert-conflict-do-nothing-2.out
View File

@ -31,7 +31,7 @@ step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT
step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; <waiting ...>
step c1: COMMIT;
step donothing2: <... completed>
error in steps c1 donothing2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step c2: COMMIT;
step show: SELECT * FROM ints;
key val
@ -45,7 +45,7 @@ step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donoth
step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; <waiting ...>
step c2: COMMIT;
step donothing1: <... completed>
error in steps c2 donothing1: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step c1: COMMIT;
step show: SELECT * FROM ints;
key val
@ -83,7 +83,7 @@ step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT
step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; <waiting ...>
step c1: COMMIT;
step donothing2: <... completed>
error in steps c1 donothing2: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step c2: COMMIT;
step show: SELECT * FROM ints;
key val
@ -97,7 +97,7 @@ step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donoth
step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; <waiting ...>
step c2: COMMIT;
step donothing1: <... completed>
error in steps c2 donothing1: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step c1: COMMIT;
step show: SELECT * FROM ints;
key val

4
src/test/isolation/expected/insert-conflict-specconflict.out
View File

@ -284,7 +284,7 @@ key data
k1 inserted s1 with conflict update s2
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 controller_print_speculative_locks s2_commit controller_show controller_print_speculative_locks
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?
@ -380,6 +380,7 @@ t
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)
@ -398,6 +399,7 @@ 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

24
src/test/isolation/expected/lock-committed-keyupdate.out
View File

@ -192,7 +192,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -216,7 +216,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -240,7 +240,7 @@ t
step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...>
step s1c: COMMIT;
step s2l: <... completed>
error in steps s1c s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -269,7 +269,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -298,7 +298,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -322,7 +322,7 @@ t
step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...>
step s1c: COMMIT;
step s2l: <... completed>
error in steps s1c s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1hint: SELECT * FROM lcku_table;
id value
@ -351,7 +351,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -375,7 +375,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -399,7 +399,7 @@ t
step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...>
step s1c: COMMIT;
step s2l: <... completed>
error in steps s1c s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -428,7 +428,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -457,7 +457,7 @@ pg_advisory_unlock
t
step s2l: <... completed>
error in steps s1ul s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
pg_advisory_unlock_all
@ -481,7 +481,7 @@ t
step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...>
step s1c: COMMIT;
step s2l: <... completed>
error in steps s1c s2l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1hint: SELECT * FROM lcku_table;
id value

8
src/test/isolation/expected/lock-update-delete_1.out
View File

@ -14,7 +14,7 @@ pg_advisory_unlock
t
step s2c: COMMIT;
step s1l: <... completed>
error in steps s2c s1l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
starting permutation: s2b s1l s2u s2_blocker2 s2_unlock s2c
pg_advisory_lock
@ -30,7 +30,7 @@ pg_advisory_unlock
t
step s2c: COMMIT;
step s1l: <... completed>
error in steps s2c s1l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
starting permutation: s2b s1l s2u s2_blocker3 s2_unlock s2c
pg_advisory_lock
@ -118,7 +118,7 @@ pg_advisory_unlock
t
step s1l: <... completed>
error in steps s2_unlock s1l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
starting permutation: s2b s1l s2u s2_blocker2 s2c s2_unlock
pg_advisory_lock
@ -134,7 +134,7 @@ pg_advisory_unlock
t
step s1l: <... completed>
error in steps s2_unlock s1l: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
starting permutation: s2b s1l s2u s2_blocker3 s2c s2_unlock
pg_advisory_lock

3
src/test/isolation/expected/multiple-cic.out
View File

@ -12,8 +12,9 @@ step s1i:
step s2i:
CREATE INDEX CONCURRENTLY mcic_two_pkey ON mcic_two (id)
WHERE unlck();
<waiting ...>
step s1i: <... completed>
step s2i: <... completed>
unlck
t

20
src/test/isolation/expected/multiple-cic_1.out
View File

@ -1,20 +0,0 @@
Parsed test spec with 2 sessions
starting permutation: s2l s1i s2i
step s2l: SELECT pg_advisory_lock(281457);
pg_advisory_lock
step s1i:
CREATE INDEX CONCURRENTLY mcic_one_pkey ON mcic_one (id)
WHERE lck_shr(281457);
<waiting ...>
step s2i:
CREATE INDEX CONCURRENTLY mcic_two_pkey ON mcic_two (id)
WHERE unlck();
<waiting ...>
step s1i: <... completed>
step s2i: <... completed>
unlck
t

4
src/test/isolation/expected/multixact-no-forget_1.out
View File

@ -83,7 +83,7 @@ step s1_commit: COMMIT;
step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; <waiting ...>
step s2_commit: COMMIT;
step s3_fornokeyupd: <... completed>
error in steps s2_commit s3_fornokeyupd: ERROR: could not serialize access due to concurrent update
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;
@ -123,4 +123,4 @@ step s1_commit: COMMIT;
step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...>
step s2_commit: COMMIT;
step s3_forupd: <... completed>
error in steps s2_commit s3_forupd: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update

2
src/test/isolation/expected/nowait-4.out
View File

@ -14,6 +14,6 @@ pg_advisory_unlock
t
step s1a: <... completed>
error in steps s2e s1a: ERROR: could not obtain lock on row in relation "foo"
ERROR: could not obtain lock on row in relation "foo"
step s1b: COMMIT;
step s2f: COMMIT;

2
src/test/isolation/expected/nowait-4_1.out
View File

@ -14,6 +14,6 @@ pg_advisory_unlock
t
step s1a: <... completed>
error in steps s2e s1a: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1b: COMMIT;
step s2f: COMMIT;

2
src/test/isolation/expected/nowait-5.out
View File

@ -34,4 +34,4 @@ pg_advisory_unlock
t
step sl1_exec: <... completed>
error in steps upd_releaselock sl1_exec: ERROR: could not obtain lock on row in relation "test_nowait"
ERROR: could not obtain lock on row in relation "test_nowait"

6
src/test/isolation/expected/partition-concurrent-attach.out
View File

@ -7,7 +7,7 @@ step s2b: begin;
step s2i: insert into tpart values (110,'xxx'), (120, 'yyy'), (150, 'zzz'); <waiting ...>
step s1c: commit;
step s2i: <... completed>
error in steps s1c s2i: ERROR: new row for relation "tpart_default" violates partition constraint
ERROR: new row for relation "tpart_default" violates partition constraint
step s2c: commit;
step s2s: select tableoid::regclass, * from tpart;
tableoid i j
@ -23,7 +23,7 @@ step s2b: begin;
step s2i2: insert into tpart_default (i, j) values (110, 'xxx'), (120, 'yyy'), (150, 'zzz'); <waiting ...>
step s1c: commit;
step s2i2: <... completed>
error in steps s1c s2i2: ERROR: new row for relation "tpart_default" violates partition constraint
ERROR: new row for relation "tpart_default" violates partition constraint
step s2c: commit;
step s2s: select tableoid::regclass, * from tpart;
tableoid i j
@ -39,7 +39,7 @@ 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); <waiting ...>
step s2c: commit;
step s1a: <... completed>
error in steps s2c s1a: ERROR: updated partition constraint for default partition "tpart_default_default" would be violated by some row
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

14
src/test/isolation/expected/partition-key-update-1.out
View File

@ -15,7 +15,7 @@ step s1u: UPDATE foo SET a=2 WHERE a=1;
step s2d: DELETE FROM foo WHERE a=1; <waiting ...>
step s1c: COMMIT;
step s2d: <... completed>
error in steps s1c s2d: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s1u s2u s1c s2c
@ -25,7 +25,7 @@ step s1u: UPDATE foo SET a=2 WHERE a=1;
step s2u: UPDATE foo SET b='EFG' WHERE a=1; <waiting ...>
step s1c: COMMIT;
step s2u: <... completed>
error in steps s1c s2u: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s2d s1u s2c s1c
@ -52,7 +52,7 @@ step s1u2: UPDATE footrg SET b='EFG' WHERE a=1;
step s2u2: UPDATE footrg SET b='XYZ' WHERE a=1; <waiting ...>
step s1c: COMMIT;
step s2u2: <... completed>
error in steps s1c s2u2: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s2u2 s1u2 s2c s1c
@ -62,7 +62,7 @@ step s2u2: UPDATE footrg SET b='XYZ' WHERE a=1;
step s1u2: UPDATE footrg SET b='EFG' WHERE a=1; <waiting ...>
step s2c: COMMIT;
step s1u2: <... completed>
error in steps s2c s1u2: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s1c: COMMIT;
starting permutation: s1b s2b s1u3pc s2i s1c s2c
@ -72,7 +72,7 @@ step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7;
step s2i: INSERT INTO bar VALUES(7); <waiting ...>
step s1c: COMMIT;
step s2i: <... completed>
error in steps s1c s2i: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s1u3pc s2i s1r s2c
@ -92,7 +92,7 @@ step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7;
step s2i: INSERT INTO bar VALUES(7); <waiting ...>
step s1c: COMMIT;
step s2i: <... completed>
error in steps s1c s2i: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s1u3npc s1u3pc s2i s1r s2c
@ -114,7 +114,7 @@ step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7;
step s2i: INSERT INTO bar VALUES(7); <waiting ...>
step s1c: COMMIT;
step s2i: <... completed>
error in steps s1c s2i: ERROR: tuple to be locked was already moved to another partition due to concurrent update
ERROR: tuple to be locked was already moved to another partition due to concurrent update
step s2c: COMMIT;
starting permutation: s1b s2b s1u3npc s1u3pc s1u3pc s2i s1r s2c

12
src/test/isolation/expected/partition-key-update-3.out
View File

@ -23,7 +23,7 @@ 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; <waiting ...>
step s1c: COMMIT;
step s3donothing: <... completed>
error in steps s1c s3donothing: ERROR: could not serialize access due to concurrent update
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;
@ -42,7 +42,7 @@ step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session
step s1c: COMMIT;
step s2donothing: <... completed>
step s3donothing: <... completed>
error in steps s1c s2donothing s3donothing: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
step s3c: COMMIT;
step s2select: SELECT * FROM foo ORDER BY a;
@ -59,8 +59,8 @@ step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session
step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...>
step s1c: COMMIT;
step s3donothing: <... completed>
ERROR: could not serialize access due to concurrent update
step s2donothing: <... completed>
error in steps s1c s3donothing s2donothing: ERROR: could not serialize access due to concurrent update
step s3c: COMMIT;
step s2c: COMMIT;
step s2select: SELECT * FROM foo ORDER BY a;
@ -92,7 +92,7 @@ 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; <waiting ...>
step s1c: COMMIT;
step s3donothing: <... completed>
error in steps s1c s3donothing: ERROR: could not serialize access due to concurrent update
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;
@ -111,7 +111,7 @@ step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session
step s1c: COMMIT;
step s2donothing: <... completed>
step s3donothing: <... completed>
error in steps s1c s2donothing s3donothing: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s2c: COMMIT;
step s3c: COMMIT;
step s2select: SELECT * FROM foo ORDER BY a;
@ -128,8 +128,8 @@ step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session
step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...>
step s1c: COMMIT;
step s3donothing: <... completed>
ERROR: could not serialize access due to concurrent update
step s2donothing: <... completed>
error in steps s1c s3donothing s2donothing: ERROR: could not serialize access due to concurrent update
step s3c: COMMIT;
step s2c: COMMIT;
step s2select: SELECT * FROM foo ORDER BY a;

16
src/test/isolation/expected/propagate-lock-delete.out
View File

@ -11,7 +11,7 @@ step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s2c: COMMIT;
step s3d: <... completed>
error in steps s2c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s2b s2l s3b s3u s3svu s3d s1c s2c s3c
@ -26,7 +26,7 @@ step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s2c: COMMIT;
step s3d: <... completed>
error in steps s2c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s2b s2l s3b s3u2 s3d s1c s2c s3c
@ -40,7 +40,7 @@ step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s2c: COMMIT;
step s3d: <... completed>
error in steps s2c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s2b s2l s3b s3u2 s3svu s3d s1c s2c s3c
@ -55,7 +55,7 @@ step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s2c: COMMIT;
step s3d: <... completed>
error in steps s2c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s3b s3u s3d s1c s3c
@ -66,7 +66,7 @@ step s3u: UPDATE parent SET c=lower(c);
step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s3d: <... completed>
error in steps s1c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s3b s3u s3svu s3d s1c s3c
@ -78,7 +78,7 @@ step s3svu: SAVEPOINT f; UPDATE parent SET c = 'bbb'; ROLLBACK TO f;
step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s3d: <... completed>
error in steps s1c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s3b s3u2 s3d s1c s3c
@ -89,7 +89,7 @@ step s3u2: UPDATE parent SET i = i;
step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s3d: <... completed>
error in steps s1c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;
starting permutation: s1b s1l s3b s3u2 s3svu s3d s1c s3c
@ -101,5 +101,5 @@ step s3svu: SAVEPOINT f; UPDATE parent SET c = 'bbb'; ROLLBACK TO f;
step s3d: DELETE FROM parent; <waiting ...>
step s1c: COMMIT;
step s3d: <... completed>
error in steps s1c s3d: ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
ERROR: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child"
step s3c: COMMIT;

2
src/test/isolation/expected/read-write-unique-2.out
View File

@ -11,7 +11,7 @@ step w1: INSERT INTO test VALUES (42);
step w2: INSERT INTO test VALUES (42); <waiting ...>
step c1: COMMIT;
step w2: <... completed>
error in steps c1 w2: ERROR: could not serialize access due to read/write dependencies among transactions
ERROR: could not serialize access due to read/write dependencies among transactions
step c2: COMMIT;
starting permutation: r1 w1 c1 r2 w2 c2

2
src/test/isolation/expected/read-write-unique-3.out
View File

@ -8,5 +8,5 @@ insert_unique
step rw2: SELECT insert_unique(1, '2'); <waiting ...>
step c1: COMMIT;
step rw2: <... completed>
error in steps c1 rw2: ERROR: could not serialize access due to read/write dependencies among transactions
ERROR: could not serialize access due to read/write dependencies among transactions
step c2: COMMIT;

6
src/test/isolation/expected/read-write-unique-4.out
View File

@ -13,7 +13,7 @@ step w1: INSERT INTO invoice VALUES (2016, 3);
step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...>
step c1: COMMIT;
step w2: <... completed>
error in steps c1 w2: ERROR: could not serialize access due to read/write dependencies among transactions
ERROR: could not serialize access due to read/write dependencies among transactions
step c2: COMMIT;
starting permutation: r1 w1 w2 c1 c2
@ -25,7 +25,7 @@ step w1: INSERT INTO invoice VALUES (2016, 3);
step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...>
step c1: COMMIT;
step w2: <... completed>
error in steps c1 w2: ERROR: duplicate key value violates unique constraint "invoice_pkey"
ERROR: duplicate key value violates unique constraint "invoice_pkey"
step c2: COMMIT;
starting permutation: r2 w1 w2 c1 c2
@ -37,5 +37,5 @@ step w1: INSERT INTO invoice VALUES (2016, 3);
step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...>
step c1: COMMIT;
step w2: <... completed>
error in steps c1 w2: ERROR: duplicate key value violates unique constraint "invoice_pkey"
ERROR: duplicate key value violates unique constraint "invoice_pkey"
step c2: COMMIT;

2
src/test/isolation/expected/read-write-unique.out
View File

@ -11,7 +11,7 @@ step w1: INSERT INTO test VALUES (42);
step w2: INSERT INTO test VALUES (42); <waiting ...>
step c1: COMMIT;
step w2: <... completed>
error in steps c1 w2: ERROR: could not serialize access due to read/write dependencies among transactions
ERROR: could not serialize access due to read/write dependencies among transactions
step c2: COMMIT;
starting permutation: r1 w1 c1 r2 w2 c2

2
src/test/isolation/expected/sequence-ddl.out
View File

@ -11,7 +11,7 @@ step s1alter: ALTER SEQUENCE seq1 MAXVALUE 10;
step s2nv: SELECT nextval('seq1') FROM generate_series(1, 15); <waiting ...>
step s1commit: COMMIT;
step s2nv: <... completed>
error in steps s1commit s2nv: ERROR: nextval: reached maximum value of sequence "seq1" (10)
ERROR: nextval: reached maximum value of sequence "seq1" (10)
starting permutation: s1restart s2nv s1commit
step s1restart: ALTER SEQUENCE seq1 RESTART WITH 5;

2
src/test/isolation/expected/skip-locked-4_1.out
View File

@ -14,6 +14,6 @@ pg_advisory_unlock
t
step s1a: <... completed>
error in steps s2e s1a: ERROR: could not serialize access due to concurrent update
ERROR: could not serialize access due to concurrent update
step s1b: COMMIT;
step s2f: COMMIT;

16
src/test/isolation/expected/timeouts.out
View File

@ -6,7 +6,7 @@ accountid balance
checking 600
savings 600
step sto: SET statement_timeout = 5000;
step sto: SET statement_timeout = '10ms';
step locktbl: LOCK TABLE accounts; <waiting ...>
step locktbl: <... completed>
ERROR: canceling statement due to statement timeout
@ -17,7 +17,7 @@ accountid balance
checking 600
savings 600
step lto: SET lock_timeout = 5000;
step lto: SET lock_timeout = '10ms';
step locktbl: LOCK TABLE accounts; <waiting ...>
step locktbl: <... completed>
ERROR: canceling statement due to lock timeout
@ -28,7 +28,7 @@ accountid balance
checking 600
savings 600
step lsto: SET lock_timeout = 5000; SET statement_timeout = 6000;
step lsto: SET lock_timeout = '10ms'; SET statement_timeout = '10s';
step locktbl: LOCK TABLE accounts; <waiting ...>
step locktbl: <... completed>
ERROR: canceling statement due to lock timeout
@ -39,35 +39,35 @@ accountid balance
checking 600
savings 600
step slto: SET lock_timeout = 6000; SET statement_timeout = 5000;
step slto: SET lock_timeout = '10s'; SET statement_timeout = '10ms';
step locktbl: LOCK TABLE accounts; <waiting ...>
step locktbl: <... completed>
ERROR: canceling statement due to statement timeout
starting permutation: wrtbl sto update
step wrtbl: UPDATE accounts SET balance = balance + 100;
step sto: SET statement_timeout = 5000;
step sto: SET statement_timeout = '10ms';
step update: DELETE FROM accounts WHERE accountid = 'checking'; <waiting ...>
step update: <... completed>
ERROR: canceling statement due to statement timeout
starting permutation: wrtbl lto update
step wrtbl: UPDATE accounts SET balance = balance + 100;
step lto: SET lock_timeout = 5000;
step lto: SET lock_timeout = '10ms';
step update: DELETE FROM accounts WHERE accountid = 'checking'; <waiting ...>
step update: <... completed>
ERROR: canceling statement due to lock timeout
starting permutation: wrtbl lsto update
step wrtbl: UPDATE accounts SET balance = balance + 100;
step lsto: SET lock_timeout = 5000; SET statement_timeout = 6000;
step lsto: SET lock_timeout = '10ms'; SET statement_timeout = '10s';
step update: DELETE FROM accounts WHERE accountid = 'checking'; <waiting ...>
step update: <... completed>
ERROR: canceling statement due to lock timeout
starting permutation: wrtbl slto update
step wrtbl: UPDATE accounts SET balance = balance + 100;
step slto: SET lock_timeout = 6000; SET statement_timeout = 5000;
step slto: SET lock_timeout = '10s'; SET statement_timeout = '10ms';
step update: DELETE FROM accounts WHERE accountid = 'checking'; <waiting ...>
step update: <... completed>
ERROR: canceling statement due to statement timeout

21
src/test/isolation/expected/tuplelock-update.out
View File

@ -18,19 +18,22 @@ step s1_grablock: SELECT * FROM pktab FOR KEY SHARE;
id data
1 2
step s1_advunlock1: SELECT pg_advisory_unlock(142857);
step s1_advunlock1: SELECT pg_advisory_unlock(142857); <waiting ...>
step s2_update: <... completed>
step s1_advunlock1: <... completed>
pg_advisory_unlock
t
step s2_update: <... completed>
step s1_advunlock2: SELECT pg_sleep(5), pg_advisory_unlock(285714);
pg_sleep pg_advisory_unlock
t
step s1_advunlock2: SELECT pg_advisory_unlock(285714); <waiting ...>
step s3_update: <... completed>
step s1_advunlock3: SELECT pg_sleep(5), pg_advisory_unlock(571428);
pg_sleep pg_advisory_unlock
step s1_advunlock2: <... completed>
pg_advisory_unlock
t
t
step s1_advunlock3: SELECT pg_advisory_unlock(571428); <waiting ...>
step s4_update: <... completed>
step s1_advunlock3: <... completed>
pg_advisory_unlock
t
step s1_commit: COMMIT;

782
src/test/isolation/isolationtester.c
View File

File diff suppressed because it is too large Load Diff

47
src/test/isolation/isolationtester.h
View File

@ -14,31 +14,62 @@
#ifndef ISOLATIONTESTER_H
#define ISOLATIONTESTER_H
typedef struct Session Session;
/*
* The structs declared here are used in the output of specparse.y.
* Except where noted, all fields are set in the grammar and not
* changed thereafter.
*/
typedef struct Step Step;
struct Session
typedef struct
{
char *name;
char *setupsql;
char *teardownsql;
Step **steps;
int nsteps;
};
} Session;
struct Step
{
int session;
bool used;
char *name;
char *sql;
char *errormsg;
/* These fields are filled by check_testspec(): */
int session; /* identifies owning session */
bool used; /* has step been used in a permutation? */
};
typedef enum
{
PSB_ONCE, /* force step to wait once */
PSB_OTHER_STEP, /* wait for another step to complete first */
PSB_NUM_NOTICES /* wait for N notices from another session */
} PermutationStepBlockerType;
typedef struct
{
char *stepname;
PermutationStepBlockerType blocktype;
int num_notices; /* only used for PSB_NUM_NOTICES */
/* These fields are filled by check_testspec(): */
Step *step; /* link to referenced step (if any) */
/* These fields are runtime workspace: */
int target_notices; /* total notices needed from other session */
} PermutationStepBlocker;
typedef struct
{
char *name; /* name of referenced Step */
PermutationStepBlocker **blockers;
int nblockers;
/* These fields are filled by check_testspec(): */
Step *step; /* link to referenced Step */
} PermutationStep;
typedef struct
{
int nsteps;
char **stepnames;
PermutationStep **steps;
} Permutation;
typedef struct
@ -50,8 +81,6 @@ typedef struct
int nsessions;
Permutation **permutations;
int npermutations;
Step **allsteps;
int nallsteps;
} TestSpec;
extern TestSpec parseresult;

87
src/test/isolation/specparse.y
View File

@ -25,9 +25,12 @@ TestSpec parseresult; /* result of parsing is left here */
%union
{
char *str;
int integer;
Session *session;
Step *step;
Permutation *permutation;
PermutationStep *permutationstep;
PermutationStepBlocker *blocker;
struct
{
void **elements;
@ -39,13 +42,16 @@ TestSpec parseresult; /* result of parsing is left here */
%type <str> opt_setup opt_teardown
%type <str> setup
%type <ptr_list> step_list session_list permutation_list opt_permutation_list
%type <ptr_list> string_literal_list
%type <ptr_list> permutation_step_list blocker_list
%type <session> session
%type <step> step
%type <permutation> permutation
%type <permutationstep> permutation_step
%type <blocker> blocker
%token <str> sqlblock string_literal
%token PERMUTATION SESSION SETUP STEP TEARDOWN TEST
%token <integer> INTEGER
%token NOTICES PERMUTATION SESSION SETUP STEP TEARDOWN TEST
%%
@ -145,8 +151,8 @@ step:
$$ = pg_malloc(sizeof(Step));
$$->name = $2;
$$->sql = $3;
$$->session = -1; /* until filled */
$$->used = false;
$$->errormsg = NULL;
}
;
@ -180,23 +186,23 @@ permutation_list:
permutation:
PERMUTATION string_literal_list
PERMUTATION permutation_step_list
{
$$ = pg_malloc(sizeof(Permutation));
$$->stepnames = (char **) $2.elements;
$$->nsteps = $2.nelements;
$$->steps = (PermutationStep **) $2.elements;
}
;
string_literal_list:
string_literal_list string_literal
permutation_step_list:
permutation_step_list permutation_step
{
$$.elements = pg_realloc($1.elements,
($1.nelements + 1) * sizeof(void *));
$$.elements[$1.nelements] = $2;
$$.nelements = $1.nelements + 1;
}
| string_literal
| permutation_step
{
$$.nelements = 1;
$$.elements = pg_malloc(sizeof(void *));
@ -204,6 +210,71 @@ string_literal_list:
}
;
permutation_step:
string_literal
{
$$ = pg_malloc(sizeof(PermutationStep));
$$->name = $1;
$$->blockers = NULL;
$$->nblockers = 0;
$$->step = NULL;
}
| string_literal '(' blocker_list ')'
{
$$ = pg_malloc(sizeof(PermutationStep));
$$->name = $1;
$$->blockers = (PermutationStepBlocker **) $3.elements;
$$->nblockers = $3.nelements;
$$->step = NULL;
}
;
blocker_list:
blocker_list ',' blocker
{
$$.elements = pg_realloc($1.elements,
($1.nelements + 1) * sizeof(void *));
$$.elements[$1.nelements] = $3;
$$.nelements = $1.nelements + 1;
}
| blocker
{
$$.nelements = 1;
$$.elements = pg_malloc(sizeof(void *));
$$.elements[0] = $1;
}
;
blocker:
string_literal
{
$$ = pg_malloc(sizeof(PermutationStepBlocker));
$$->stepname = $1;
$$->blocktype = PSB_OTHER_STEP;
$$->num_notices = -1;
$$->step = NULL;
$$->target_notices = -1;
}
| string_literal NOTICES INTEGER
{
$$ = pg_malloc(sizeof(PermutationStepBlocker));
$$->stepname = $1;
$$->blocktype = PSB_NUM_NOTICES;
$$->num_notices = $3;
$$->step = NULL;
$$->target_notices = -1;
}
| '*'
{
$$ = pg_malloc(sizeof(PermutationStepBlocker));
$$->stepname = NULL;
$$->blocktype = PSB_ONCE;
$$->num_notices = -1;
$$->step = NULL;
$$->target_notices = -1;
}
;
%%
#include "specscanner.c"

12
src/test/isolation/specs/deadlock-hard.spec
View File

@ -63,9 +63,17 @@ step "s7a8" { LOCK TABLE a8; }
step "s7c" { COMMIT; }
session "s8"
setup { BEGIN; SET deadlock_timeout = '10s'; }
setup { BEGIN; SET deadlock_timeout = '10ms'; }
step "s8a8" { LOCK TABLE a8; }
step "s8a1" { LOCK TABLE a1; }
step "s8c" { COMMIT; }
permutation "s1a1" "s2a2" "s3a3" "s4a4" "s5a5" "s6a6" "s7a7" "s8a8" "s1a2" "s2a3" "s3a4" "s4a5" "s5a6" "s6a7" "s7a8" "s8a1" "s8c" "s7c" "s6c" "s5c" "s4c" "s3c" "s2c" "s1c"
# Note: when s8a1 detects the deadlock and fails, s7a8 is released, making
# it timing-dependent which query completion is received first by the tester.
# To ensure output stability, add a blocking mark to force s8a1's completion
# to be reported first. There is a second timing dependency, too: the tester
# might or might not observe s8a1 during its short lock wait state. Apply a
# dummy blocking mark to s8a1 to ensure it will be reported as "waiting"
# regardless of that.
permutation "s1a1" "s2a2" "s3a3" "s4a4" "s5a5" "s6a6" "s7a7" "s8a8" "s1a2" "s2a3" "s3a4" "s4a5" "s5a6" "s6a7" "s7a8"("s8a1") "s8a1"(*) "s8c" "s7c" "s6c" "s5c" "s4c" "s3c" "s2c" "s1c"

15
src/test/isolation/specs/deadlock-soft-2.spec
View File

@ -2,12 +2,6 @@
# jump over both s3 and s4 and acquire the lock on a2 immediately,
# since s3 and s4 are hard-blocked on a1.
# The expected output for this test assumes that isolationtester will
# detect step s1b as waiting before the deadlock detector runs and
# releases s1 from its blocked state. To leave enough time for that
# to happen even in very slow (CLOBBER_CACHE_ALWAYS) cases, we must
# increase deadlock_timeout.
setup
{
CREATE TABLE a1 ();
@ -20,7 +14,7 @@ teardown
}
session "s1"
setup { BEGIN; SET deadlock_timeout = '5s'; }
setup { BEGIN; SET deadlock_timeout = '10ms'; }
step "s1a" { LOCK TABLE a1 IN SHARE UPDATE EXCLUSIVE MODE; }
step "s1b" { LOCK TABLE a2 IN SHARE UPDATE EXCLUSIVE MODE; }
step "s1c" { COMMIT; }
@ -41,4 +35,9 @@ setup { BEGIN; SET deadlock_timeout = '100s'; }
step "s4a" { LOCK TABLE a2 IN ACCESS EXCLUSIVE MODE; }
step "s4c" { COMMIT; }
permutation "s1a" "s2a" "s2b" "s3a" "s4a" "s1b" "s1c" "s2c" "s3c" "s4c"
# The expected output for this test assumes that isolationtester will
# detect step s1b as waiting before the deadlock detector runs and
# releases s1 from its blocked state. To ensure that happens even in
# very slow (CLOBBER_CACHE_ALWAYS) cases, apply a (*) annotation.
permutation "s1a" "s2a" "s2b" "s3a" "s4a" "s1b"(*) "s1c" "s2c" "s3c" "s4c"

50
src/test/isolation/specs/detach-partition-concurrently-3.spec
View File

@ -1,8 +1,11 @@
# Try various things to happen to a partition with an incomplete detach
#
# Note: Always keep "s2noop" right after "s1cancel" in permutations. This
# reduces the probability of the timing problem that the cancel error report
# is shown together with the next query instead of with the cancel query.
# Note: When using "s1cancel", mark the target step (the one to be canceled)
# as being blocked by "s1cancel". This ensures consistent reporting regardless
# of whether "s1cancel" returns before or after the other step reports failure.
# Also, ensure the step after "s1cancel" is also an s1 step (use "s1noop" if
# necessary). This ensures we won't move on to the next step until the cancel
# is complete.
setup
{
@ -22,8 +25,8 @@ step "s1b" { BEGIN; }
step "s1brr" { BEGIN ISOLATION LEVEL REPEATABLE READ; }
step "s1s" { SELECT * FROM d3_listp; }
step "s1spart" { SELECT * FROM d3_listp1; }
# Sleep 0.1s after sending cancel, to give s2 time to react
step "s1cancel" { SELECT pg_cancel_backend(pid), pg_sleep(0.1) FROM d3_pid; }
step "s1cancel" { SELECT pg_cancel_backend(pid) FROM d3_pid; }
step "s1noop" { }
step "s1c" { COMMIT; }
step "s1alter" { ALTER TABLE d3_listp1 ALTER a DROP NOT NULL; }
step "s1insert" { INSERT INTO d3_listp VALUES (1); }
@ -41,44 +44,43 @@ step "s2begin" { BEGIN; }
step "s2snitch" { INSERT INTO d3_pid SELECT pg_backend_pid(); }
step "s2detach" { ALTER TABLE d3_listp DETACH PARTITION d3_listp1 CONCURRENTLY; }
step "s2detach2" { ALTER TABLE d3_listp DETACH PARTITION d3_listp2 CONCURRENTLY; }
step "s2noop" { UNLISTEN noop; }
step "s2detachfinal" { ALTER TABLE d3_listp DETACH PARTITION d3_listp1 FINALIZE; }
step "s2drop" { DROP TABLE d3_listp1; }
step "s2commit" { COMMIT; }
# Try various things while the partition is in "being detached" state, with
# no session waiting.
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1describe" "s1alter"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c"
permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c" "s1spart"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1insertpart"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1describe" "s1alter"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1insert" "s1c"
permutation "s2snitch" "s1brr" "s1s" "s2detach"("s1cancel") "s1cancel" "s1insert" "s1c" "s1spart"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1insertpart"
# Test partition descriptor caching
permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s2noop" "s1c" "s1brr" "s1insert" "s1s" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach2" "s1cancel" "s2noop" "s1c" "s1brr" "s1s" "s1insert" "s1s" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach2"("s1cancel") "s1cancel" "s1c" "s1brr" "s1insert" "s1s" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach2"("s1cancel") "s1cancel" "s1c" "s1brr" "s1s" "s1insert" "s1s" "s1c"
# "drop" here does both tables
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1drop" "s1list"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1drop" "s1list"
# "truncate" only does parent, not partition
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1trunc" "s1spart"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1trunc" "s1spart"
# If a partition pending detach exists, we cannot drop another one
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s2detach2" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s2detachfinal" "s1c" "s2detach2"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1droppart" "s2detach2"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1noop" "s2detach2" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1noop" "s2detachfinal" "s1c" "s2detach2"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1droppart" "s2detach2"
# When a partition with incomplete detach is dropped, we grab lock on parent too.
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2drop" "s1s" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s2begin" "s2drop" "s1s" "s2commit"
# Partially detach, then select and try to complete the detach. Reading
# from partition blocks (AEL is required on partition); reading from parent
# does not block.
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1s" "s2detachfinal" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1b" "s1s" "s2detachfinal" "s1c"
# DETACH FINALIZE in a transaction block. No insert/select on the partition
# is allowed concurrently with that.
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s1spart" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1c" "s2begin" "s2detachfinal" "s1insertpart" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s1b" "s1spart" "s2detachfinal" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s2begin" "s2detachfinal" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s2begin" "s2detachfinal" "s1spart" "s2commit"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1c" "s2begin" "s2detachfinal" "s1insertpart" "s2commit"

34
src/test/isolation/specs/detach-partition-concurrently-4.spec
View File

@ -4,9 +4,12 @@
# because the locking situation is completely different. I didn't verify
# that keeping both variants adds any extra coverage.)
#
# Note: Always keep "s2noop" right after "s1cancel" in permutations. This
# reduces the probability of the timing problem that the cancel error report
# is shown together with the next query instead of with the cancel query.
# Note: When using "s1cancel", mark the target step (the one to be canceled)
# as being blocked by "s1cancel". This ensures consistent reporting regardless
# of whether "s1cancel" returns before or after the other step reports failure.
# Also, ensure the step after "s1cancel" is also an s1 step (use "s1noop" if
# necessary). This ensures we won't move on to the next step until the cancel
# is complete.
setup {
drop table if exists d4_primary, d4_primary1, d4_fk, d4_pid;
@ -24,8 +27,8 @@ session "s1"
step "s1b" { begin; }
step "s1brr" { begin isolation level repeatable read; }
step "s1s" { select * from d4_primary; }
# Sleep 0.1s after sending cancel, to give s2 time to react
step "s1cancel" { select pg_cancel_backend(pid), pg_sleep(0.1) from d4_pid; }
step "s1cancel" { select pg_cancel_backend(pid) from d4_pid; }
step "s1noop" { }
step "s1insert" { insert into d4_fk values (1); }
step "s1c" { commit; }
step "s1declare" { declare f cursor for select * from d4_primary; }
@ -39,7 +42,6 @@ step "s1rollback" { rollback to f; }
session "s2"
step "s2snitch" { insert into d4_pid select pg_backend_pid(); }
step "s2detach" { alter table d4_primary detach partition d4_primary1 concurrently; }
step "s2noop" { UNLISTEN noop; }
session "s3"
step "s3brr" { begin isolation level repeatable read; }
@ -48,34 +50,34 @@ step "s3commit" { commit; }
step "s3vacfreeze" { vacuum freeze pg_catalog.pg_inherits; }
# Trying to insert into a partially detached partition is rejected
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1insert" "s1c"
# ... even under REPEATABLE READ mode.
permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1cancel" "s2noop" "s1insert" "s1c"
permutation "s2snitch" "s1brr" "s1s" "s2detach"("s1cancel") "s1cancel" "s1insert" "s1c"
permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1insert" "s1c"
# If you read the referenced table using a cursor, you can see a row that the
# RI query does not see.
permutation "s2snitch" "s1b" "s1declare" "s2detach" "s1cancel" "s2noop" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1declare" "s2detach"("s1cancel") "s1cancel" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1declare" "s2detach" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1declare" "s2detach" "s1cancel" "s2noop" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
permutation "s2snitch" "s1b" "s1declare" "s2detach"("s1cancel") "s1cancel" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
permutation "s2snitch" "s1b" "s1declare" "s2detach" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
permutation "s2snitch" "s1b" "s2detach" "s1declare" "s1cancel" "s2noop" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s2detach"("s1cancel") "s1declare" "s1cancel" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s2detach" "s1declare" "s1fetchall" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s2detach" "s1declare" "s1cancel" "s2noop" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
permutation "s2snitch" "s1b" "s2detach"("s1cancel") "s1declare" "s1cancel" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
permutation "s2snitch" "s1b" "s2detach" "s1declare" "s1svpt" "s1insert" "s1rollback" "s1fetchall" "s1c"
# Creating the referencing row using a cursor
permutation "s2snitch" "s1brr" "s1declare2" "s1fetchone" "s2detach" "s1cancel" "s2noop" "s1updcur" "s1c"
permutation "s2snitch" "s1brr" "s1declare2" "s1fetchone" "s2detach"("s1cancel") "s1cancel" "s1updcur" "s1c"
permutation "s2snitch" "s1brr" "s1declare2" "s1fetchone" "s2detach" "s1updcur" "s1c"
permutation "s2snitch" "s1brr" "s1declare2" "s1fetchone" "s1updcur" "s2detach" "s1c"
# Try reading the table from an independent session.
permutation "s2snitch" "s1b" "s1s" "s2detach" "s3insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s3brr" "s3insert" "s3commit" "s1cancel" "s2noop" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s3brr" "s3insert" "s3commit" "s1cancel" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s3brr" "s3insert" "s3commit" "s1c"
# Try one where we VACUUM FREEZE pg_inherits (to verify that xmin change is
# handled correctly).
permutation "s2snitch" "s1brr" "s1s" "s2detach" "s1cancel" "s2noop" "s3vacfreeze" "s1s" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach" "s1cancel" "s2noop" "s3vacfreeze" "s1s" "s1insert" "s1c"
permutation "s2snitch" "s1brr" "s1s" "s2detach"("s1cancel") "s1cancel" "s1noop" "s3vacfreeze" "s1s" "s1insert" "s1c"
permutation "s2snitch" "s1b" "s1s" "s2detach"("s1cancel") "s1cancel" "s1noop" "s3vacfreeze" "s1s" "s1insert" "s1c"

16
src/test/isolation/specs/insert-conflict-specconflict.spec
View File

@ -83,6 +83,7 @@ step "s1_confirm_index_order" { SELECT 'upserttest_key_uniq_idx'::regclass::int8
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'; }
step "s1_insert_toast" { INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; }
step "s1_commit" { COMMIT; }
step "s1_noop" { }
session "s2"
setup
@ -95,6 +96,7 @@ step "s2_begin" { BEGIN; }
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 "s2_insert_toast" { INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; }
step "s2_commit" { COMMIT; }
step "s2_noop" { }
# Test that speculative locks are correctly acquired and released, s2
# inserts, s1 updates.
@ -223,7 +225,8 @@ permutation
"controller_show"
"s2_begin"
# Both sessions wait on advisory locks
"s1_upsert" "s2_upsert"
# (but don't show s2_upsert as complete till we've seen all of s1's notices)
"s1_upsert" "s2_upsert" ("s1_upsert" notices 10)
"controller_show"
# Switch both sessions to wait on the other lock next time (the speculative insertion)
"controller_unlock_1_1" "controller_unlock_2_1"
@ -244,14 +247,15 @@ permutation
"controller_unlock_1_2"
# Should report s1 is waiting on speculative lock
"controller_print_speculative_locks"
# Allow s2 to insert into the non-unique index and complete s1 will
# Allow s2 to insert into the non-unique index and complete. s1 will
# no longer wait on speculative lock, but proceed to wait on the
# transaction to finish.
"controller_unlock_2_4"
# Should report that s1 is now waiting for s1 to commit
# transaction to finish. The no-op step is needed to ensure that
# we don't advance to the reporting step until s2_upsert has completed.
"controller_unlock_2_4" "s2_noop"
# Should report that s1 is now waiting for s2 to commit
"controller_print_speculative_locks"
# Once s2 commits, s1 is finally free to continue to update
"s2_commit"
"s2_commit" "s1_noop"
# This should now show a successful UPSERT
"controller_show"
# Ensure no unexpected locks survive

5
src/test/isolation/specs/multiple-cic.spec
View File

@ -37,4 +37,7 @@ step "s2i" {
WHERE unlck();
}
permutation "s2l" "s1i" "s2i"
# (*) marker ensures that s2i is reported as "waiting", even if it
# completes very quickly
permutation "s2l" "s1i" "s2i"(*)

28
src/test/isolation/specs/timeouts.spec
View File

@ -19,27 +19,31 @@ teardown { ABORT; }
session "s2"
setup { BEGIN ISOLATION LEVEL READ COMMITTED; }
step "sto" { SET statement_timeout = 5000; }
step "lto" { SET lock_timeout = 5000; }
step "lsto" { SET lock_timeout = 5000; SET statement_timeout = 6000; }
step "slto" { SET lock_timeout = 6000; SET statement_timeout = 5000; }
step "sto" { SET statement_timeout = '10ms'; }
step "lto" { SET lock_timeout = '10ms'; }
step "lsto" { SET lock_timeout = '10ms'; SET statement_timeout = '10s'; }
step "slto" { SET lock_timeout = '10s'; SET statement_timeout = '10ms'; }
step "locktbl" { LOCK TABLE accounts; }
step "update" { DELETE FROM accounts WHERE accountid = 'checking'; }
teardown { ABORT; }
# It's possible that the isolation tester will not observe the final
# steps as "waiting", thanks to the relatively short timeouts we use.
# We can ensure consistent test output by marking those steps with (*).
# statement timeout, table-level lock
permutation "rdtbl" "sto" "locktbl"
permutation "rdtbl" "sto" "locktbl"(*)
# lock timeout, table-level lock
permutation "rdtbl" "lto" "locktbl"
permutation "rdtbl" "lto" "locktbl"(*)
# lock timeout expires first, table-level lock
permutation "rdtbl" "lsto" "locktbl"
permutation "rdtbl" "lsto" "locktbl"(*)
# statement timeout expires first, table-level lock
permutation "rdtbl" "slto" "locktbl"
permutation "rdtbl" "slto" "locktbl"(*)
# statement timeout, row-level lock
permutation "wrtbl" "sto" "update"
permutation "wrtbl" "sto" "update"(*)
# lock timeout, row-level lock
permutation "wrtbl" "lto" "update"
permutation "wrtbl" "lto" "update"(*)
# lock timeout expires first, row-level lock
permutation "wrtbl" "lsto" "update"
permutation "wrtbl" "lsto" "update"(*)
# statement timeout expires first, row-level lock
permutation "wrtbl" "slto" "update"
permutation "wrtbl" "slto" "update"(*)

9
src/test/isolation/specs/tuplelock-update.spec
View File

@ -18,8 +18,8 @@ step "s1_chain" { UPDATE pktab SET data = DEFAULT; }
step "s1_begin" { BEGIN; }
step "s1_grablock" { SELECT * FROM pktab FOR KEY SHARE; }
step "s1_advunlock1" { SELECT pg_advisory_unlock(142857); }
step "s1_advunlock2" { SELECT pg_sleep(5), pg_advisory_unlock(285714); }
step "s1_advunlock3" { SELECT pg_sleep(5), pg_advisory_unlock(571428); }
step "s1_advunlock2" { SELECT pg_advisory_unlock(285714); }
step "s1_advunlock3" { SELECT pg_advisory_unlock(571428); }
step "s1_commit" { COMMIT; }
session "s2"
@ -31,4 +31,7 @@ step "s3_update" { UPDATE pktab SET data = DEFAULT WHERE pg_advisory_lock_shared
session "s4"
step "s4_update" { UPDATE pktab SET data = DEFAULT WHERE pg_advisory_lock_shared(571428) IS NOT NULL; }
permutation "s1_advlock" "s2_update" "s3_update" "s4_update" "s1_chain" "s1_begin" "s1_grablock" "s1_advunlock1" "s1_advunlock2" "s1_advunlock3" "s1_commit"
# We use blocker annotations on the s1_advunlockN steps so that we will not
# move on to the next step until the other session's released step finishes.
# This ensures stable ordering of the test output.
permutation "s1_advlock" "s2_update" "s3_update" "s4_update" "s1_chain" "s1_begin" "s1_grablock" "s1_advunlock1"("s2_update") "s1_advunlock2"("s3_update") "s1_advunlock3"("s4_update") "s1_commit"

12
src/test/isolation/specscanner.l
View File

@ -36,6 +36,10 @@ static void addlitchar(char c);
%x sql
%x qstr
digit [0123456789]
self [,()*]
non_newline [^\n\r]
space [ \t\r\f]
@ -48,12 +52,20 @@ comment ("#"{non_newline}*)
litbufsize = LITBUF_INIT;
%}
notices { return NOTICES; }
permutation { return PERMUTATION; }
session { return SESSION; }
setup { return SETUP; }
step { return STEP; }
teardown { return TEARDOWN; }
{digit}+ {
yylval.integer = atoi(yytext);
return INTEGER;
}
{self} { return yytext[0]; }
[\n] { yyline++; }
{comment} { /* ignore */ }
{space} { /* ignore */ }