diff options
Diffstat (limited to 'src/test/isolation/expected')
103 files changed, 78311 insertions, 0 deletions
diff --git a/src/test/isolation/expected/aborted-keyrevoke.out b/src/test/isolation/expected/aborted-keyrevoke.out new file mode 100644 index 0000000..a035426 --- /dev/null +++ b/src/test/isolation/expected/aborted-keyrevoke.out @@ -0,0 +1,272 @@ +Parsed test spec with 2 sessions + +starting permutation: s1s s1u s1r s1l s1c s2l s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s1l s2l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s1l s2l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s1r s2l s1l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s2l s1l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s1r s2l s2c s1l s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s1s s1u s2l s1r s1l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s2l s1r s1l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s2l s1r s2c s1l s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s1s s2l s1u s2c s1r s1l s1c +step s1s: SAVEPOINT f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1u: UPDATE foo SET key = 2; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s1s s2l s2c s1u s1r s1l s1c +step s1s: SAVEPOINT f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s2l s1s s1u s2c s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s2l s1s s2c s1u s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1s: SAVEPOINT f; +step s2c: COMMIT; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; + +starting permutation: s2l s2c s1s s1u s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; diff --git a/src/test/isolation/expected/aborted-keyrevoke_2.out b/src/test/isolation/expected/aborted-keyrevoke_2.out new file mode 100644 index 0000000..c286964 --- /dev/null +++ b/src/test/isolation/expected/aborted-keyrevoke_2.out @@ -0,0 +1,218 @@ +Parsed test spec with 2 sessions + +starting permutation: s1s s1u s1r s1l s1c s2l s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s1l s2l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s1l s2l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s1r s2l s1l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s1r s2l s1l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s1r s2l s2c s1l s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s1s s1u s2l s1r s1l s1c s2c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key value + +1 1 +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1s s1u s2l s1r s1l s2c s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key value + +1 1 +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1s s1u s2l s1r s2c s1l s1c +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s2l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l: <... completed> +key value + +1 1 +step s2c: COMMIT; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s1s s2l s1u s2c s1r s1l s1c +step s1s: SAVEPOINT f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1u: UPDATE foo SET key = 2; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +error in steps s2c s1u: ERROR: could not serialize access due to concurrent update +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s1s s2l s2c s1u s1r s1l s1c +step s1s: SAVEPOINT f; +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s2l s1s s1u s2c s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +error in steps s2c s1u: ERROR: could not serialize access due to concurrent update +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s2l s1s s2c s1u s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1s: SAVEPOINT f; +step s2c: COMMIT; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; + +starting permutation: s2l s2c s1s s1u s1r s1l s1c +step s2l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s2c: COMMIT; +step s1s: SAVEPOINT f; +step s1u: UPDATE foo SET key = 2; +step s1r: ROLLBACK TO f; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key value + +1 1 +step s1c: COMMIT; diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out new file mode 100644 index 0000000..5e88174 --- /dev/null +++ b/src/test/isolation/expected/alter-table-1.out @@ -0,0 +1,3326 @@ +Parsed test spec with 2 sessions + +starting permutation: s1 at1 sc1 s2 at2 sc2 rx1 wx rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 at2 rx1 sc2 wx rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 at2 rx1 wx sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 at2 rx1 wx rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 at2 rx1 wx rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 at2 sc2 wx rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 at2 wx sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 at2 wx rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 at2 wx rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 s2 rx1 wx rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 at2 sc2 wx rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 at2 wx sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 at2 wx rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 at2 wx rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 s2 wx rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx s2 rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx rx3 s2 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx rx3 s2 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx rx3 s2 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 sc1 rx1 wx rx3 c2 s2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 s2 wx rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx s2 rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx rx3 s2 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx rx3 s2 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx rx3 s2 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 sc1 wx rx3 c2 s2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx3 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx3 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx3 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 rx3 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 rx3 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 s2 rx3 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 rx3 s2 at2 sc2 c2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 rx3 s2 at2 c2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 rx3 s2 c2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 at1 rx1 wx sc1 rx3 c2 s2 at2 sc2 +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx3 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx3 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx3 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx3 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx3 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx3 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx3 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx rx3 at2 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx rx3 at2 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 s2 wx rx3 c2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx3 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx3 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx3 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 rx3 at2 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 rx3 at2 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx s2 rx3 c2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx rx3 s2 at2 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx rx3 s2 at2 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx rx3 s2 c2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 sc1 wx rx3 c2 s2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx3 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx3 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx3 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 rx3 at2 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 rx3 at2 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 s2 rx3 c2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 rx3 s2 at2 sc2 c2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 rx3 s2 at2 c2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 rx3 s2 c2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 at1 wx sc1 rx3 c2 s2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 wx at1 rx3 c2 sc1 s2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 wx rx3 at1 c2 sc1 s2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: s1 rx1 wx rx3 c2 at1 sc1 s2 at2 sc2 +step s1: BEGIN; +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx3 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx3 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx3 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx3 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx3 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx3 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx3 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx rx3 at2 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx rx3 at2 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 s2 wx rx3 c2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx3 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx3 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx3 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 rx3 at2 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 rx3 at2 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx s2 rx3 c2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx rx3 s2 at2 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx rx3 s2 at2 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx rx3 s2 c2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 sc1 wx rx3 c2 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx3 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx3 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx3 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 rx3 at2 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 rx3 at2 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 s2 rx3 c2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step s2: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 rx3 s2 at2 sc2 c2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; +step c2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 rx3 s2 at2 c2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step c2: COMMIT; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 rx3 s2 c2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s2: BEGIN; +step c2: COMMIT; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 at1 wx sc1 rx3 c2 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step wx: INSERT INTO b VALUES (0); <waiting ...> +step sc1: COMMIT; +step wx: <... completed> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 wx at1 rx3 c2 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step wx: INSERT INTO b VALUES (0); +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 wx rx3 at1 c2 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 s1 wx rx3 c2 at1 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step s1: BEGIN; +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx s1 at1 rx3 c2 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx s1 rx3 at1 c2 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s1: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx s1 rx3 c2 at1 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step s1: BEGIN; +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx rx3 s1 at1 c2 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step c2: COMMIT; +step at1: <... completed> +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx rx3 s1 c2 at1 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step s1: BEGIN; +step c2: COMMIT; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; + +starting permutation: rx1 wx rx3 c2 s1 at1 sc1 s2 at2 sc2 +step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; +a_id +---- + 1 +(1 row) + +step wx: INSERT INTO b VALUES (0); +step rx3: SELECT * FROM b WHERE a_id = 3 LIMIT 3; +a_id +---- + 3 + 3 + 3 +(3 rows) + +step c2: COMMIT; +step s1: BEGIN; +step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step sc1: COMMIT; +step s2: BEGIN; +step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk; +step sc2: COMMIT; diff --git a/src/test/isolation/expected/alter-table-2.out b/src/test/isolation/expected/alter-table-2.out new file mode 100644 index 0000000..819bc33 --- /dev/null +++ b/src/test/isolation/expected/alter-table-2.out @@ -0,0 +1,1030 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s1b s1c s2a s2b s2c s2d s2e s2f +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s1b s2a s1c s2b s2c s2d s2e s2f +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2a: BEGIN; +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s1b s2a s2b s1c s2c s2d s2e s2f +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s1b s2a s2b s2c s1c s2d s2e s2f +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s1b s2a s2b s2c s2d s1c s2e s2f +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s1b s1c s2b s2c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s1b s2b s1c s2c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s1b s2b s2c s1c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s1b s2b s2c s2d s1c s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s1b s1c s2c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s1b s2c s1c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s1b s2c s2d s1c s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s1c s2d s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s2d s1c s2e s2f +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s1a s2a s2b s2c s2d s1b s2e s2f s1c +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s1a s2a s2b s2c s2d s2e s1b s2f s1c +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s1a s2a s2b s2c s2d s2e s2f s1b s1c +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s1a s1b s1c s2b s2c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s1b s2b s1c s2c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s1b s2b s2c s1c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s1b s2b s2c s2d s1c s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s1b s1c s2c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c s1c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c s2d s1c s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s1c s2d s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s2d s1c s2e s2f +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s1a s2b s2c s2d s1b s2e s2f s1c +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f s1c +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s1a s2b s2c s2d s2e s2f s1b s1c +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s1b s1c s2c s2d s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c s1c s2d s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c s2d s1c s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s1c s2d s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s2d s1c s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s1a s2c s2d s1b s2e s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s2c s2d s2e s1b s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s2c s2d s2e s2f s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s1c s2d s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s2d s1c s2e s2f +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s2d: INSERT INTO b VALUES (0); <waiting ...> +step s1c: COMMIT; +step s2d: <... completed> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; + +starting permutation: s2a s2b s2c s1a s2d s1b s2e s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1a: BEGIN; +step s2d: INSERT INTO b VALUES (0); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s2d s2e s1b s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1a: BEGIN; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s2d s2e s2f s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s1a: BEGIN; +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s1a s1b s2e s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s1a s2e s1b s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1a: BEGIN; +step s2e: INSERT INTO a VALUES (4); +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s1a s2e s2f s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s1a: BEGIN; +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s2e s1a s1b s2f s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...> +step s2f: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s2e s1a s2f s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s1a: BEGIN; +step s2f: COMMIT; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s2e s2f s1a s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; +a_id +---- + 3 +(1 row) + +step s2d: INSERT INTO b VALUES (0); +step s2e: INSERT INTO a VALUES (4); +step s2f: COMMIT; +step s1a: BEGIN; +step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/alter-table-3.out b/src/test/isolation/expected/alter-table-3.out new file mode 100644 index 0000000..427364e --- /dev/null +++ b/src/test/isolation/expected/alter-table-3.out @@ -0,0 +1,785 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s1b s1c s1d s2a s2b s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s1c s2a s1d s2b s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2a: BEGIN; +step s1d: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s1c s2a s2b s1d s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s1c s2a s2b s2c s1d s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s1c s2b s1d s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s1c s2b s2c s1d s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s2b s1c s2c s1d s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s1c s2b s1d s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s1c s2b s2c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s2b s1c s2c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s1b s1c s2c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s1c s2d s1d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2d: COMMIT; +step s1d: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s2d s1c s1d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2d: COMMIT; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s1a s2a s2b s2c s2d s1b s1c s1d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s1a s1b s1c s1d s2b s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s1c s2b s1d s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s1c s2b s2c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s2b s1c s2c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s1b s1c s2c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s1c s2d s1d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2d: COMMIT; +step s1d: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s2d s1c s1d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2d: COMMIT; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s1a s2b s2c s2d s1b s1c s1d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s2b s1a s1b s1c s1d s2c s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s1b s1c s2c s1d s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2c: INSERT INTO a VALUES (0); <waiting ...> +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2c: <... completed> +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s1c s2d s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2d: COMMIT; +step s1d: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s2d s1c s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2d: COMMIT; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s2b s1a s2c s2d s1b s1c s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s1c s1d s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; +step s2d: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s1c s2d s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s2d: COMMIT; +step s1d: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s2d s1c s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s2d: COMMIT; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s2b s2c s1a s2d s1b s1c s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s1a: BEGIN; +step s2d: COMMIT; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; + +starting permutation: s2a s2b s2c s2d s1a s1b s1c s1d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: INSERT INTO a VALUES (0); +ERROR: duplicate key value violates unique constraint "a_pkey" +step s2d: COMMIT; +step s1a: BEGIN; +step s1b: ALTER TABLE a DISABLE TRIGGER t; +step s1c: ALTER TABLE a ENABLE TRIGGER t; +step s1d: COMMIT; diff --git a/src/test/isolation/expected/alter-table-4.out b/src/test/isolation/expected/alter-table-4.out new file mode 100644 index 0000000..fc57910 --- /dev/null +++ b/src/test/isolation/expected/alter-table-4.out @@ -0,0 +1,71 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s1delc1 s2sel s1c s2sel +step s1b: BEGIN; +step s1delc1: ALTER TABLE c1 NO INHERIT p; +step s2sel: SELECT SUM(a) FROM p; <waiting ...> +step s1c: COMMIT; +step s2sel: <... completed> +sum +--- + 11 +(1 row) + +step s2sel: SELECT SUM(a) FROM p; +sum +--- + 1 +(1 row) + + +starting permutation: s1b s1delc1 s1addc2 s2sel s1c s2sel +step s1b: BEGIN; +step s1delc1: ALTER TABLE c1 NO INHERIT p; +step s1addc2: ALTER TABLE c2 INHERIT p; +step s2sel: SELECT SUM(a) FROM p; <waiting ...> +step s1c: COMMIT; +step s2sel: <... completed> +sum +--- + 11 +(1 row) + +step s2sel: SELECT SUM(a) FROM p; +sum +--- +101 +(1 row) + + +starting permutation: s1b s1dropc1 s2sel s1c s2sel +step s1b: BEGIN; +step s1dropc1: DROP TABLE c1; +step s2sel: SELECT SUM(a) FROM p; <waiting ...> +step s1c: COMMIT; +step s2sel: <... completed> +sum +--- + 1 +(1 row) + +step s2sel: SELECT SUM(a) FROM p; +sum +--- + 1 +(1 row) + + +starting permutation: s1b s1delc1 s1modc1a s2sel s1c s2sel +step s1b: BEGIN; +step s1delc1: ALTER TABLE c1 NO INHERIT p; +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: attribute "a" of relation "c1" does not match parent's type +step s2sel: SELECT SUM(a) FROM p; +sum +--- + 1 +(1 row) + diff --git a/src/test/isolation/expected/async-notify.out b/src/test/isolation/expected/async-notify.out new file mode 100644 index 0000000..556e180 --- /dev/null +++ b/src/test/isolation/expected/async-notify.out @@ -0,0 +1,127 @@ +Parsed test spec with 3 sessions + +starting permutation: listenc notify1 notify2 notify3 notifyf +step listenc: LISTEN c1; LISTEN c2; +step notify1: NOTIFY c1; +notifier: NOTIFY "c1" with payload "" from notifier +step notify2: NOTIFY c2, 'payload'; +notifier: NOTIFY "c2" with payload "payload" from notifier +step notify3: NOTIFY c3, 'payload3'; +step notifyf: SELECT pg_notify('c2', NULL); +pg_notify +--------- + +(1 row) + +notifier: NOTIFY "c2" with payload "" from notifier + +starting permutation: listenc notifyd1 notifyd2 notifys1 +step listenc: LISTEN c1; LISTEN c2; +step notifyd1: NOTIFY c2, 'payload'; NOTIFY c1; NOTIFY "c2", 'payload'; +notifier: NOTIFY "c2" with payload "payload" from notifier +notifier: NOTIFY "c1" with payload "" from notifier +step notifyd2: NOTIFY c1; NOTIFY c1; NOTIFY c1, 'p1'; NOTIFY c1, 'p2'; +notifier: NOTIFY "c1" with payload "" from notifier +notifier: NOTIFY "c1" with payload "p1" from notifier +notifier: NOTIFY "c1" with payload "p2" from notifier +step notifys1: + BEGIN; + NOTIFY c1, 'payload'; NOTIFY "c2", 'payload'; + NOTIFY c1, 'payload'; NOTIFY "c2", 'payload'; + SAVEPOINT s1; + NOTIFY c1, 'payload'; NOTIFY "c2", 'payload'; + NOTIFY c1, 'payloads'; NOTIFY "c2", 'payloads'; + NOTIFY c1, 'payload'; NOTIFY "c2", 'payload'; + NOTIFY c1, 'payloads'; NOTIFY "c2", 'payloads'; + RELEASE SAVEPOINT s1; + SAVEPOINT s2; + NOTIFY c1, 'rpayload'; NOTIFY "c2", 'rpayload'; + NOTIFY c1, 'rpayloads'; NOTIFY "c2", 'rpayloads'; + NOTIFY c1, 'rpayload'; NOTIFY "c2", 'rpayload'; + NOTIFY c1, 'rpayloads'; NOTIFY "c2", 'rpayloads'; + ROLLBACK TO SAVEPOINT s2; + COMMIT; + +notifier: NOTIFY "c1" with payload "payload" from notifier +notifier: NOTIFY "c2" with payload "payload" from notifier +notifier: NOTIFY "c1" with payload "payloads" from notifier +notifier: NOTIFY "c2" with payload "payloads" from notifier + +starting permutation: llisten notify1 notify2 notify3 notifyf lcheck +step llisten: LISTEN c1; LISTEN c2; +step notify1: NOTIFY c1; +step notify2: NOTIFY c2, 'payload'; +step notify3: NOTIFY c3, 'payload3'; +step notifyf: SELECT pg_notify('c2', NULL); +pg_notify +--------- + +(1 row) + +step lcheck: SELECT 1 AS x; +x +- +1 +(1 row) + +listener: NOTIFY "c1" with payload "" from notifier +listener: NOTIFY "c2" with payload "payload" from notifier +listener: NOTIFY "c2" with payload "" from notifier + +starting permutation: listenc llisten notify1 notify2 notify3 notifyf lcheck +step listenc: LISTEN c1; LISTEN c2; +step llisten: LISTEN c1; LISTEN c2; +step notify1: NOTIFY c1; +notifier: NOTIFY "c1" with payload "" from notifier +step notify2: NOTIFY c2, 'payload'; +notifier: NOTIFY "c2" with payload "payload" from notifier +step notify3: NOTIFY c3, 'payload3'; +step notifyf: SELECT pg_notify('c2', NULL); +pg_notify +--------- + +(1 row) + +notifier: NOTIFY "c2" with payload "" from notifier +step lcheck: SELECT 1 AS x; +x +- +1 +(1 row) + +listener: NOTIFY "c1" with payload "" from notifier +listener: NOTIFY "c2" with payload "payload" from notifier +listener: NOTIFY "c2" with payload "" from notifier + +starting permutation: l2listen l2begin notify1 lbegins llisten lcommit l2commit l2stop +step l2listen: LISTEN c1; +step l2begin: BEGIN; +step notify1: NOTIFY c1; +step lbegins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step llisten: LISTEN c1; LISTEN c2; +step lcommit: COMMIT; +step l2commit: COMMIT; +listener2: NOTIFY "c1" with payload "" from notifier +step l2stop: UNLISTEN *; + +starting permutation: llisten lbegin usage bignotify usage +step llisten: LISTEN c1; LISTEN c2; +step lbegin: BEGIN; +step usage: SELECT pg_notification_queue_usage() > 0 AS nonzero; +nonzero +------- +f +(1 row) + +step bignotify: SELECT count(pg_notify('c1', s::text)) FROM generate_series(1, 1000) s; +count +----- + 1000 +(1 row) + +step usage: SELECT pg_notification_queue_usage() > 0 AS nonzero; +nonzero +------- +t +(1 row) + diff --git a/src/test/isolation/expected/classroom-scheduling.out b/src/test/isolation/expected/classroom-scheduling.out new file mode 100644 index 0000000..1d7c885 --- /dev/null +++ b/src/test/isolation/expected/classroom-scheduling.out @@ -0,0 +1,379 @@ +Parsed test spec with 2 sessions + +starting permutation: rx1 wy1 c1 ry2 wx2 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 1 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 c1 wx2 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step c1: COMMIT; +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 wx2 c1 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 wy1 ry2 wx2 c2 c1 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 c1 wx2 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 ry2 wy1 wx2 c1 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 wx2 c2 c1 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c1 c2 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c2 c1 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 c2 wy1 c1 +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 rx1 wy1 c1 wx2 c2 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: ry2 rx1 wy1 wx2 c1 c2 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wy1 wx2 c2 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c1 c2 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c2 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 c2 wy1 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 rx1 wy1 c1 c2 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 wy1 c2 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 c2 wy1 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 0 +(1 row) + +step c2: COMMIT; +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 c2 rx1 wy1 c1 +step ry2: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:30'; +count +----- + 0 +(1 row) + +step wx2: UPDATE room_reservation SET start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 13:30', end_time = TIMESTAMP WITH TIME ZONE '2010-04-01 14:30' WHERE room_id = '101' AND start_time = TIMESTAMP WITH TIME ZONE '2010-04-01 10:00'; +step c2: COMMIT; +step rx1: SELECT count(*) FROM room_reservation WHERE room_id = '101' AND start_time < TIMESTAMP WITH TIME ZONE '2010-04-01 14:00' AND end_time > TIMESTAMP WITH TIME ZONE '2010-04-01 13:00'; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO room_reservation VALUES ('101', TIMESTAMP WITH TIME ZONE '2010-04-01 13:00', TIMESTAMP WITH TIME ZONE '2010-04-01 14:00', 'Carol'); +step c1: COMMIT; diff --git a/src/test/isolation/expected/create-trigger.out b/src/test/isolation/expected/create-trigger.out new file mode 100644 index 0000000..7f98678 --- /dev/null +++ b/src/test/isolation/expected/create-trigger.out @@ -0,0 +1,361 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s1b s1c s2a s2b s2c s2d +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s1c s2b s2c s2d +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2a: BEGIN; +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s2b s1c s2c s2d +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s1b s2a s2b s2c s1c s2d +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s1c s2b s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s2b s1c s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s2a s1b s2b s2c s1c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s1b s1c s2c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s1b s2c s1c s2d +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s2d s1c +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...> +step s2d: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s1a s2a s2b s2c s2d s1b s1c +step s1a: BEGIN; +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; + +starting permutation: s2a s1a s1b s1c s2b s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s2b s1c s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s2a s1a s1b s2b s2c s1c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s1b s1c s2c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c s1c s2d +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s2d s1c +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...> +step s2d: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s1a s2b s2c s2d s1b s1c +step s2a: BEGIN; +step s1a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s1b s1c s2c s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c s1c s2d +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...> +step s1c: COMMIT; +step s2c: <... completed> +step s2d: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s2d s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...> +step s2d: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s2c s2d s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s1a: BEGIN; +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s2d s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...> +step s2d: COMMIT; +step s1b: <... completed> +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s2d s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s1a: BEGIN; +step s2d: COMMIT; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s2d s1a s1b s1c +step s2a: BEGIN; +step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE; +i +- +1 +(1 row) + +step s2c: UPDATE a SET i = 4 WHERE i = 3; +step s2d: COMMIT; +step s1a: BEGIN; +step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); +step s1c: COMMIT; diff --git a/src/test/isolation/expected/deadlock-hard.out b/src/test/isolation/expected/deadlock-hard.out new file mode 100644 index 0000000..460653f --- /dev/null +++ b/src/test/isolation/expected/deadlock-hard.out @@ -0,0 +1,36 @@ +Parsed test spec with 8 sessions + +starting 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 +step s1a1: LOCK TABLE a1; +step s2a2: LOCK TABLE a2; +step s3a3: LOCK TABLE a3; +step s4a4: LOCK TABLE a4; +step s5a5: LOCK TABLE a5; +step s6a6: LOCK TABLE a6; +step s7a7: LOCK TABLE a7; +step s8a8: LOCK TABLE a8; +step s1a2: LOCK TABLE a2; <waiting ...> +step s2a3: LOCK TABLE a3; <waiting ...> +step s3a4: LOCK TABLE a4; <waiting ...> +step s4a5: LOCK TABLE a5; <waiting ...> +step s5a6: LOCK TABLE a6; <waiting ...> +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> +step s8c: COMMIT; +step s7c: COMMIT; +step s6a7: <... completed> +step s6c: COMMIT; +step s5a6: <... completed> +step s5c: COMMIT; +step s4a5: <... completed> +step s4c: COMMIT; +step s3a4: <... completed> +step s3c: COMMIT; +step s2a3: <... completed> +step s2c: COMMIT; +step s1a2: <... completed> +step s1c: COMMIT; diff --git a/src/test/isolation/expected/deadlock-parallel.out b/src/test/isolation/expected/deadlock-parallel.out new file mode 100644 index 0000000..6fe5e24 --- /dev/null +++ b/src/test/isolation/expected/deadlock-parallel.out @@ -0,0 +1,68 @@ +Parsed test spec with 4 sessions + +starting permutation: d1a1 d2a2 e1l e2l d1a2 d2a1 d1c e1c d2c e2c +step d1a1: SELECT lock_share(1,x), lock_excl(3,x) FROM bigt LIMIT 1; +lock_share|lock_excl +----------+--------- + 1| 1 +(1 row) + +step d2a2: select lock_share(2,x) FROM bigt LIMIT 1; +lock_share +---------- + 1 +(1 row) + +step e1l: SELECT lock_excl(1,x) FROM bigt LIMIT 1; <waiting ...> +step e2l: SELECT lock_excl(2,x) FROM bigt LIMIT 1; <waiting ...> +step d1a2: SET force_parallel_mode = on; + SET parallel_setup_cost = 0; + SET parallel_tuple_cost = 0; + SET min_parallel_table_scan_size = 0; + SET parallel_leader_participation = off; + SET max_parallel_workers_per_gather = 3; + SELECT sum(lock_share(2,x)) FROM bigt; <waiting ...> +step d2a1: SET force_parallel_mode = on; + SET parallel_setup_cost = 0; + SET parallel_tuple_cost = 0; + SET min_parallel_table_scan_size = 0; + SET parallel_leader_participation = off; + SET max_parallel_workers_per_gather = 3; + SELECT sum(lock_share(1,x)) FROM bigt; + SET force_parallel_mode = off; + RESET parallel_setup_cost; + RESET parallel_tuple_cost; + SELECT lock_share(3,x) FROM bigt LIMIT 1; <waiting ...> +step d1a2: <... completed> + sum +----- +10000 +(1 row) + +step d1c: COMMIT; +step e1l: <... completed> +lock_excl +--------- + 1 +(1 row) + +step d2a1: <... completed> + sum +----- +10000 +(1 row) + +lock_share +---------- + 1 +(1 row) + +step e1c: COMMIT; +step d2c: COMMIT; +step e2l: <... completed> +lock_excl +--------- + 1 +(1 row) + +step e2c: COMMIT; diff --git a/src/test/isolation/expected/deadlock-simple.out b/src/test/isolation/expected/deadlock-simple.out new file mode 100644 index 0000000..8be1538 --- /dev/null +++ b/src/test/isolation/expected/deadlock-simple.out @@ -0,0 +1,11 @@ +Parsed test spec with 2 sessions + +starting permutation: s1as s2as s1ae s2ae s1c s2c +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> +step s1c: COMMIT; +step s2c: COMMIT; diff --git a/src/test/isolation/expected/deadlock-soft-2.out b/src/test/isolation/expected/deadlock-soft-2.out new file mode 100644 index 0000000..14b0343 --- /dev/null +++ b/src/test/isolation/expected/deadlock-soft-2.out @@ -0,0 +1,17 @@ +Parsed test spec with 4 sessions + +starting permutation: s1a s2a s2b s3a s4a s1b s1c s2c s3c s4c +step s1a: LOCK TABLE a1 IN SHARE UPDATE EXCLUSIVE MODE; +step s2a: LOCK TABLE a2 IN ACCESS SHARE MODE; +step s2b: LOCK TABLE a1 IN SHARE UPDATE EXCLUSIVE MODE; <waiting ...> +step s3a: LOCK TABLE a2 IN ACCESS EXCLUSIVE MODE; <waiting ...> +step s4a: LOCK TABLE a2 IN ACCESS EXCLUSIVE MODE; <waiting ...> +step s1b: LOCK TABLE a2 IN SHARE UPDATE EXCLUSIVE MODE; <waiting ...> +step s1b: <... completed> +step s1c: COMMIT; +step s2b: <... completed> +step s2c: COMMIT; +step s3a: <... completed> +step s3c: COMMIT; +step s4a: <... completed> +step s4c: COMMIT; diff --git a/src/test/isolation/expected/deadlock-soft.out b/src/test/isolation/expected/deadlock-soft.out new file mode 100644 index 0000000..24a35da --- /dev/null +++ b/src/test/isolation/expected/deadlock-soft.out @@ -0,0 +1,17 @@ +Parsed test spec with 4 sessions + +starting permutation: d1a1 d2a2 e1l e2l d1a2 d2a1 d1c e1c d2c e2c +step d1a1: LOCK TABLE a1 IN ACCESS SHARE MODE; +step d2a2: LOCK TABLE a2 IN ACCESS SHARE MODE; +step e1l: LOCK TABLE a1 IN ACCESS EXCLUSIVE MODE; <waiting ...> +step e2l: LOCK TABLE a2 IN ACCESS EXCLUSIVE MODE; <waiting ...> +step d1a2: LOCK TABLE a2 IN ACCESS SHARE MODE; <waiting ...> +step d2a1: LOCK TABLE a1 IN ACCESS SHARE MODE; <waiting ...> +step d1a2: <... completed> +step d1c: COMMIT; +step e1l: <... completed> +step e1c: COMMIT; +step d2a1: <... completed> +step d2c: COMMIT; +step e2l: <... completed> +step e2c: COMMIT; diff --git a/src/test/isolation/expected/delete-abort-savept-2.out b/src/test/isolation/expected/delete-abort-savept-2.out new file mode 100644 index 0000000..6fc991a --- /dev/null +++ b/src/test/isolation/expected/delete-abort-savept-2.out @@ -0,0 +1,100 @@ +Parsed test spec with 2 sessions + +starting permutation: s1l s1svp s1d s1r s2l s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: SELECT * FROM foo FOR NO KEY UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s1svp s1d s2l s1r s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: SELECT * FROM foo FOR NO KEY UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1r: ROLLBACK TO f; +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s1svp s1d s1r s2l2 s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: SELECT * FROM foo FOR NO KEY UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s1r: ROLLBACK TO f; +step s2l2: SELECT * FROM foo FOR NO KEY UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1l s1svp s1d s2l2 s1r s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: SELECT * FROM foo FOR NO KEY UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s2l2: SELECT * FROM foo FOR NO KEY UPDATE; <waiting ...> +step s1r: ROLLBACK TO f; +step s2l2: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; diff --git a/src/test/isolation/expected/delete-abort-savept.out b/src/test/isolation/expected/delete-abort-savept.out new file mode 100644 index 0000000..8f70bab --- /dev/null +++ b/src/test/isolation/expected/delete-abort-savept.out @@ -0,0 +1,139 @@ +Parsed test spec with 2 sessions + +starting permutation: s1l s1svp s1d s1r s1c s2l s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s1c: COMMIT; +step s2l: SELECT * FROM foo FOR UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s1svp s1d s1r s2l s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s1svp s1d s2l s1r s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1r: ROLLBACK TO f; +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s1svp s2l s1d s1r s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s1l s2l s1svp s1d s1r s1c s2c +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2l: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s1c: COMMIT; +step s2l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s2l s1l s2c s1svp s1d s1r s1c +step s2l: SELECT * FROM foo FOR UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s1l: SELECT * FROM foo FOR KEY SHARE; <waiting ...> +step s2c: COMMIT; +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s1c: COMMIT; + +starting permutation: s2l s2c s1l s1svp s1d s1r s1c +step s2l: SELECT * FROM foo FOR UPDATE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s1svp: SAVEPOINT f; +step s1d: DELETE FROM foo; +step s1r: ROLLBACK TO f; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/drop-index-concurrently-1.out b/src/test/isolation/expected/drop-index-concurrently-1.out new file mode 100644 index 0000000..97e1a6e --- /dev/null +++ b/src/test/isolation/expected/drop-index-concurrently-1.out @@ -0,0 +1,56 @@ +Parsed test spec with 3 sessions + +starting permutation: noseq chkiso prepi preps begin explaini explains select2 drop insert2 end2 selecti selects end +step noseq: SET enable_seqscan = false; +step chkiso: SELECT (setting in ('read committed','read uncommitted')) AS is_read_committed FROM pg_settings WHERE name = 'default_transaction_isolation'; +is_read_committed +----------------- +t +(1 row) + +step prepi: PREPARE getrow_idx AS SELECT * FROM test_dc WHERE data=34 ORDER BY id,data; +step preps: PREPARE getrow_seq AS SELECT * FROM test_dc WHERE data::text=34::text ORDER BY id,data; +step begin: BEGIN; +step explaini: EXPLAIN (COSTS OFF) EXECUTE getrow_idx; +QUERY PLAN +---------------------------------------------- +Sort + Sort Key: id + -> Index Scan using test_dc_data on test_dc + Index Cond: (data = 34) +(4 rows) + +step explains: EXPLAIN (COSTS OFF) EXECUTE getrow_seq; +QUERY PLAN +---------------------------------------------- +Sort + Sort Key: id, data + -> Index Scan using test_dc_pkey on test_dc + Filter: ((data)::text = '34'::text) +(4 rows) + +step select2: SELECT * FROM test_dc WHERE data=34 ORDER BY id,data; +id|data +--+---- +34| 34 +(1 row) + +step drop: DROP INDEX CONCURRENTLY test_dc_data; <waiting ...> +step insert2: INSERT INTO test_dc(data) SELECT * FROM generate_series(1, 100); +step end2: COMMIT; +step selecti: EXECUTE getrow_idx; + id|data +---+---- + 34| 34 +134| 34 +(2 rows) + +step selects: EXECUTE getrow_seq; + id|data +---+---- + 34| 34 +134| 34 +(2 rows) + +step end: COMMIT; +step drop: <... completed> diff --git a/src/test/isolation/expected/drop-index-concurrently-1_2.out b/src/test/isolation/expected/drop-index-concurrently-1_2.out new file mode 100644 index 0000000..04612d3 --- /dev/null +++ b/src/test/isolation/expected/drop-index-concurrently-1_2.out @@ -0,0 +1,54 @@ +Parsed test spec with 3 sessions + +starting permutation: noseq chkiso prepi preps begin explaini explains select2 drop insert2 end2 selecti selects end +step noseq: SET enable_seqscan = false; +step chkiso: SELECT (setting in ('read committed','read uncommitted')) AS is_read_committed FROM pg_settings WHERE name = 'default_transaction_isolation'; +is_read_committed +----------------- +f +(1 row) + +step prepi: PREPARE getrow_idx AS SELECT * FROM test_dc WHERE data=34 ORDER BY id,data; +step preps: PREPARE getrow_seq AS SELECT * FROM test_dc WHERE data::text=34::text ORDER BY id,data; +step begin: BEGIN; +step explaini: EXPLAIN (COSTS OFF) EXECUTE getrow_idx; +QUERY PLAN +---------------------------------------------- +Sort + Sort Key: id + -> Index Scan using test_dc_data on test_dc + Index Cond: (data = 34) +(4 rows) + +step explains: EXPLAIN (COSTS OFF) EXECUTE getrow_seq; +QUERY PLAN +---------------------------------------------- +Sort + Sort Key: id, data + -> Index Scan using test_dc_pkey on test_dc + Filter: ((data)::text = '34'::text) +(4 rows) + +step select2: SELECT * FROM test_dc WHERE data=34 ORDER BY id,data; +id|data +--+---- +34| 34 +(1 row) + +step drop: DROP INDEX CONCURRENTLY test_dc_data; <waiting ...> +step insert2: INSERT INTO test_dc(data) SELECT * FROM generate_series(1, 100); +step end2: COMMIT; +step selecti: EXECUTE getrow_idx; +id|data +--+---- +34| 34 +(1 row) + +step selects: EXECUTE getrow_seq; +id|data +--+---- +34| 34 +(1 row) + +step end: COMMIT; +step drop: <... completed> diff --git a/src/test/isolation/expected/eval-plan-qual-trigger.out b/src/test/isolation/expected/eval-plan-qual-trigger.out new file mode 100644 index 0000000..f6714c2 --- /dev/null +++ b/src/test/isolation/expected/eval-plan-qual-trigger.out @@ -0,0 +1,2734 @@ +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 +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +key-b|val-b-s1 +(2 rows) + + +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_r s2_upd_a_data s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s1_c s2_del_a s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1-ups1) new: <NULL> +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1-ups1) new: <NULL> +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s1_r s2_del_a s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +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 s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +key-b|val-b-s1 +(2 rows) + + +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 s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +step s2_upd_a_data: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_a_i s1_trig_rep_a_d s1_b_rc s2_b_rc s1_ins_a s2_ins_a s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s2) +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: duplicate key value violates unique constraint "trigtest_pkey" +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_a_i s1_trig_rep_a_d s1_b_rc s2_b_rc s1_ins_a s2_ins_a s1_r s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s2) +step s2_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s2') RETURNING *; <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s2) +step s2_ins_a: <... completed> +key |data +-----+-------- +key-a|val-a-s2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-a|val-a-s2 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upsert_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +step s2_upsert_a_data: <... completed> +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upsert_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +step s2_upsert_a_data: <... completed> +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_b_rc s2_b_rc s1_ins_a s2_upsert_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-upserts2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-upserts2) +step s2_upsert_a_data: <... completed> +key |data +-----+----------------- +key-a|val-a-s1-upserts2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+----------------- +key-a|val-a-s1-upserts2 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_b_rc s2_b_rc s1_ins_a s2_upsert_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: <... completed> +key |data +-----+----------- +key-a|val-a-upss2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+----------- +key-a|val-a-upss2 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_b_rc s2_b_rc s1_ins_a s1_upd_a_data s2_upsert_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-upserts2) +step s2_upsert_a_data: <... completed> +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+---------------------- +key-a|val-a-s1-ups1-upserts2 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_b_rc s2_b_rc s1_ins_a s1_upd_a_data s2_upsert_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: + INSERT INTO trigtest VALUES ('key-a', 'val-a-upss2') + ON CONFLICT (key) + DO UPDATE SET data = trigtest.data || '-upserts2' + WHERE + noisy_oper('upd', trigtest.key, '=', 'key-a') AND + noisy_oper('upk', trigtest.data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-upss2) +step s2_upsert_a_data: <... completed> +key |data +-----+----------- +key-a|val-a-upss2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+----------- +key-a|val-a-upss2 +(1 row) + + +starting permutation: s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1-ups1) new: (key-a,val-a-s1-ups1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------------ +key-a|val-a-s1-ups1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_del_a s1_c s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1-ups1 <> text mismatch: t +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1-ups1) new: <NULL> +step s2_del_a: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_upd_a_data s2_del_a s1_r s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s2_del_a: <... completed> +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +step s2_upd_a_data: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_a_d s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_del_a s1_c s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +step s2_del_a: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_a_d s1_ins_a s1_ins_b s1_b_rc s2_b_rc s1_del_a s2_del_a s1_r s2_c s0_rep +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s2_del_a: <... completed> +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_upd_a_tob s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upk: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +s1: NOTICE: upk: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +step s1_upd_a_tob: + UPDATE trigtest SET key = 'key-b', data = data || '-tobs1' + WHERE + noisy_oper('upk', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: upd: text key-c = text key-a: f +step s2_upd_a_data: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +key-c|val-c-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_upd_a_tob s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upk: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +s1: NOTICE: upk: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +step s1_upd_a_tob: + UPDATE trigtest SET key = 'key-b', data = data || '-tobs1' + WHERE + noisy_oper('upk', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-c = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-c|val-c-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_upd_a_tob s2_upd_b_data s1_c s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upk: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +s1: NOTICE: upk: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +step s1_upd_a_tob: + UPDATE trigtest SET key = 'key-b', data = data || '-tobs1' + WHERE + noisy_oper('upk', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-b: f +s2: NOTICE: upd: text key-c = text key-b: f +step s2_upd_b_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-b') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key|data +---+---- +(0 rows) + +step s1_c: COMMIT; +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +key-c|val-c-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_upd_a_tob s2_upd_all_data s1_c s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upk: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +s1: NOTICE: upk: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +step s1_upd_a_tob: + UPDATE trigtest SET key = 'key-b', data = data || '-tobs1' + WHERE + noisy_oper('upk', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + +s2: NOTICE: upd: text key-a <> text mismatch: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_all_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '<>', 'mismatch') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-b <> text mismatch: t +s2: NOTICE: upk: text val-a-s1-tobs1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-b,val-a-s1-tobs1) new: (key-b,val-a-s1-tobs1-ups2) +s2: NOTICE: upd: text key-c <> text mismatch: t +s2: NOTICE: upk: text val-c-s1 <> text mismatch: t +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-c,val-c-s1) new: (key-c,val-c-s1-ups2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-b,val-a-s1-tobs1) new: (key-b,val-a-s1-tobs1-ups2) +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-c,val-c-s1) new: (key-c,val-c-s1-ups2) +step s2_upd_all_data: <... completed> +key |data +-----+------------------- +key-b|val-a-s1-tobs1-ups2 +key-c|val-c-s1-ups2 +(2 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------------- +key-b|val-a-s1-tobs1-ups2 +key-c|val-c-s1-ups2 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-c = text key-a: f +step s2_upd_a_data: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_del_a s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-c = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-c|val-c-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_a_d s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_del_a s2_del_a s1_c s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_c: COMMIT; +s2: NOTICE: upd: text key-c = text key-a: f +step s2_del_a: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_a_d s1_ins_a s1_ins_c s1_b_rc s2_b_rc s1_del_a s2_del_a s1_r s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *; +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-c = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s2: NOTICE: upd: text key-c = text key-a: f +s2: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s2_del_a: <... completed> +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------- +key-c|val-c-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_i s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_i s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_b s1_b_rc s2_b_rc s1_ins_a s1_upd_b_data s2_upd_b_data s1_del_b s1_upd_a_tob s1_c s2_c s0_rep +step s1_trig_rep_b_i: CREATE TRIGGER rep_b_i BEFORE INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_i: CREATE TRIGGER rep_a_i AFTER INSERT ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-b,val-b-s1) +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: trigger: name rep_b_i; when: BEFORE; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +s1: NOTICE: trigger: name rep_a_i; when: AFTER; lev: ROWs; op: INSERT; old: <NULL> new: (key-a,val-a-s1) +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s1: NOTICE: upd: text key-b = text key-b: t +s1: NOTICE: upk: text val-b-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-b,val-b-s1) new: (key-b,val-b-s1-ups1) +s1: NOTICE: upd: text key-a = text key-b: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-b,val-b-s1) new: (key-b,val-b-s1-ups1) +step s1_upd_b_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-b') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-b|val-b-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-b = text key-b: t +s2: NOTICE: upk: text val-b-s1 <> text mismatch: t +step s2_upd_b_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-b') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +s1: NOTICE: upd: text key-a = text key-b: f +s1: NOTICE: upd: text key-b = text key-b: t +s1: NOTICE: upk: text val-b-s1-ups1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-b,val-b-s1-ups1) new: <NULL> +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-b,val-b-s1-ups1) new: <NULL> +step s1_del_b: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-b') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+------------- +key-b|val-b-s1-ups1 +(1 row) + +s1: NOTICE: upk: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-b,val-a-s1-tobs1) +step s1_upd_a_tob: + UPDATE trigtest SET key = 'key-b', data = data || '-tobs1' + WHERE + noisy_oper('upk', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + +step s1_c: COMMIT; +step s2_upd_b_data: <... completed> +key|data +---+---- +(0 rows) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+-------------- +key-b|val-a-s1-tobs1 +(1 row) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rr s2_b_rr s1_upd_a_data s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +step s2_upd_a_data: <... completed> +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 +-----+------------- +key-a|val-a-s1-ups1 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_u s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rr s2_b_rr s1_upd_a_data s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups1) +step s1_upd_a_data: + UPDATE trigtest SET data = data || '-ups1' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + +key |data +-----+------------- +key-a|val-a-s1-ups1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rr s2_b_rr s1_del_a s2_upd_a_data s1_c s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_c: COMMIT; +step s2_upd_a_data: <... completed> +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 +-----+-------- +key-b|val-b-s1 +(1 row) + + +starting permutation: s1_trig_rep_b_d s1_trig_rep_b_u s1_trig_rep_a_d s1_trig_rep_a_u s1_ins_a s1_ins_b s1_b_rr s2_b_rr s1_del_a s2_upd_a_data s1_r s2_c s0_rep +step s1_trig_rep_b_d: CREATE TRIGGER rep_b_d BEFORE DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_b_u: CREATE TRIGGER rep_b_u BEFORE UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_d: CREATE TRIGGER rep_a_d AFTER DELETE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_trig_rep_a_u: CREATE TRIGGER rep_a_u AFTER UPDATE ON trigtest FOR EACH ROW EXECUTE PROCEDURE trig_report(); +step s1_ins_a: INSERT INTO trigtest VALUES ('key-a', 'val-a-s1') RETURNING *; +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *; +key |data +-----+-------- +key-b|val-b-s1 +(1 row) + +step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1; +?column? +-------- + 1 +(1 row) + +s1: NOTICE: upd: text key-a = text key-a: t +s1: NOTICE: upk: text val-a-s1 <> text mismatch: t +s1: NOTICE: trigger: name rep_b_d; when: BEFORE; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +s1: NOTICE: upd: text key-b = text key-a: f +s1: NOTICE: trigger: name rep_a_d; when: AFTER; lev: ROWs; op: DELETE; old: (key-a,val-a-s1) new: <NULL> +step s1_del_a: + DELETE FROM trigtest + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING * + +key |data +-----+-------- +key-a|val-a-s1 +(1 row) + +s2: NOTICE: upd: text key-a = text key-a: t +s2: NOTICE: upk: text val-a-s1 <> text mismatch: t +step s2_upd_a_data: + UPDATE trigtest SET data = data || '-ups2' + WHERE + noisy_oper('upd', key, '=', 'key-a') AND + noisy_oper('upk', data, '<>', 'mismatch') + RETURNING *; + <waiting ...> +step s1_r: ROLLBACK; +s2: NOTICE: trigger: name rep_b_u; when: BEFORE; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +s2: NOTICE: upd: text key-b = text key-a: f +s2: NOTICE: trigger: name rep_a_u; when: AFTER; lev: ROWs; op: UPDATE; old: (key-a,val-a-s1) new: (key-a,val-a-s1-ups2) +step s2_upd_a_data: <... completed> +key |data +-----+------------- +key-a|val-a-s1-ups2 +(1 row) + +step s2_c: COMMIT; +step s0_rep: SELECT * FROM trigtest ORDER BY key, data +key |data +-----+------------- +key-a|val-a-s1-ups2 +key-b|val-b-s1 +(2 rows) + diff --git a/src/test/isolation/expected/eval-plan-qual.out b/src/test/isolation/expected/eval-plan-qual.out new file mode 100644 index 0000000..d906350 --- /dev/null +++ b/src/test/isolation/expected/eval-plan-qual.out @@ -0,0 +1,1179 @@ +Parsed test spec with 3 sessions + +starting permutation: wx1 wx2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step c1: COMMIT; +step wx2: <... completed> +balance +------- + 850 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 850 +savings | 600 +(2 rows) + + +starting permutation: wy1 wy2 c1 c2 read +step wy1: UPDATE accounts SET balance = balance + 500 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1100 +(1 row) + +step wy2: UPDATE accounts SET balance = balance + 1000 WHERE accountid = 'checking' AND balance < 1000 RETURNING balance; <waiting ...> +step c1: COMMIT; +step wy2: <... completed> +balance +------- +(0 rows) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1100 +savings | 600 +(2 rows) + + +starting permutation: wx1 wx2 r1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step r1: ROLLBACK; +step wx2: <... completed> +balance +------- + 1050 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1050 +savings | 600 +(2 rows) + + +starting permutation: wy1 wy2 r1 c2 read +step wy1: UPDATE accounts SET balance = balance + 500 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1100 +(1 row) + +step wy2: UPDATE accounts SET balance = balance + 1000 WHERE accountid = 'checking' AND balance < 1000 RETURNING balance; <waiting ...> +step r1: ROLLBACK; +step wy2: <... completed> +balance +------- + 1600 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1600 +savings | 600 +(2 rows) + + +starting permutation: wx1 d1 wx2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; +balance +------- + 400 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step c1: COMMIT; +step wx2: <... completed> +balance +------- +(0 rows) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: wx2 d1 c2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step c2: COMMIT; +step d1: <... completed> +balance +------- + 1050 +(1 row) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: wx2 wx2 d1 c2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1500 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step c2: COMMIT; +step d1: <... completed> +balance +------- +(0 rows) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1500 +savings | 600 +(2 rows) + + +starting permutation: wx2 d2 d1 c2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step d2: DELETE FROM accounts WHERE accountid = 'checking'; +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step c2: COMMIT; +step d1: <... completed> +balance +------- +(0 rows) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: wx1 d1 wx2 r1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; +balance +------- + 400 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step r1: ROLLBACK; +step wx2: <... completed> +balance +------- + 1050 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1050 +savings | 600 +(2 rows) + + +starting permutation: wx2 d1 r2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step r2: ROLLBACK; +step d1: <... completed> +balance +------- + 600 +(1 row) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: wx2 wx2 d1 r2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1500 +(1 row) + +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step r2: ROLLBACK; +step d1: <... completed> +balance +------- + 600 +(1 row) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: wx2 d2 d1 r2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step d2: DELETE FROM accounts WHERE accountid = 'checking'; +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; <waiting ...> +step r2: ROLLBACK; +step d1: <... completed> +balance +------- + 600 +(1 row) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: d1 wx2 c1 c2 read +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; +balance +------- + 600 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step c1: COMMIT; +step wx2: <... completed> +balance +------- +(0 rows) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +savings | 600 +(1 row) + + +starting permutation: d1 wx2 r1 c2 read +step d1: DELETE FROM accounts WHERE accountid = 'checking' AND balance < 1500 RETURNING balance; +balance +------- + 600 +(1 row) + +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; <waiting ...> +step r1: ROLLBACK; +step wx2: <... completed> +balance +------- + 1050 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1050 +savings | 600 +(2 rows) + + +starting permutation: wnested2 c1 c2 read +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +s2: NOTICE: upid: text savings = text checking: f +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + +step c1: COMMIT; +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | -600 +savings | 600 +(2 rows) + + +starting permutation: wx1 wxext1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 400 > numeric 200.0: t +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 400 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 400 > numeric 200.0: t +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | -800 +savings | 600 +(2 rows) + + +starting permutation: wx1 wx1 wxext1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 200 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 400 > numeric 200.0: t +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 200 > numeric 200.0: f +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 200 +savings | 600 +(2 rows) + + +starting permutation: wx1 wx1 wxext1 wxext1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 200 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 200 +(1 row) + +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 200 > numeric 200.0: f +s2: NOTICE: lock_id: text savings = text checking: f +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 200 +savings | 600 +(2 rows) + + +starting permutation: wx1 wxext1 wxext1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step wxext1: UPDATE accounts_ext SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 200 +(1 row) + +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 200 > numeric 200.0: f +s2: NOTICE: lock_id: text savings = text checking: f +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 400 +savings | 600 +(2 rows) + + +starting permutation: wx1 tocds1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step tocds1: UPDATE accounts SET accountid = 'cds' WHERE accountid = 'checking'; +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: upid: text cds = text checking: f +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +cds | 400 +savings | 600 +(2 rows) + + +starting permutation: wx1 tocdsext1 wnested2 c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step tocdsext1: UPDATE accounts_ext SET accountid = 'cds' WHERE accountid = 'checking'; +s2: NOTICE: upid: text checking = text checking: t +s2: NOTICE: up: numeric 600 > numeric 200.0: t +s2: NOTICE: lock_id: text checking = text checking: t +s2: NOTICE: lock_bal: numeric 600 > numeric 200.0: t +step wnested2: + UPDATE accounts SET balance = balance - 1200 + WHERE noisy_oper('upid', accountid, '=', 'checking') + AND noisy_oper('up', balance, '>', 200.0) + AND EXISTS ( + SELECT accountid + FROM accounts_ext ae + WHERE noisy_oper('lock_id', ae.accountid, '=', accounts.accountid) + AND noisy_oper('lock_bal', ae.balance, '>', 200.0) + FOR UPDATE + ); + <waiting ...> +step c1: COMMIT; +s2: NOTICE: lock_id: text cds = text checking: f +s2: NOTICE: lock_id: text savings = text checking: f +s2: NOTICE: upid: text savings = text checking: f +step wnested2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 400 +savings | 600 +(2 rows) + + +starting permutation: wx1 updwcte c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step updwcte: WITH doup AS (UPDATE accounts SET balance = balance + 1100 WHERE accountid = 'checking' RETURNING *) UPDATE accounts a SET balance = doup.balance + 100 FROM doup RETURNING *; <waiting ...> +step c1: COMMIT; +step updwcte: <... completed> +accountid|balance|accountid|balance +---------+-------+---------+------- +savings | 1600|checking | 1500 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1500 +savings | 1600 +(2 rows) + + +starting permutation: wx1 updwctefail c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +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: 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 +---------+------- +checking | 400 +savings | 600 +(2 rows) + + +starting permutation: wx1 delwcte c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +step delwcte: WITH doup AS (UPDATE accounts SET balance = balance + 1100 WHERE accountid = 'checking' RETURNING *) DELETE FROM accounts a USING doup RETURNING *; <waiting ...> +step c1: COMMIT; +step delwcte: <... completed> +accountid|balance|accountid|balance +---------+-------+---------+------- +savings | 600|checking | 1500 +(1 row) + +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1500 +(1 row) + + +starting permutation: wx1 delwctefail c1 c2 read +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 400 +(1 row) + +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: 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 +---------+------- +checking | 400 +savings | 600 +(2 rows) + + +starting permutation: upsert1 upsert2 c1 c2 read +step upsert1: + WITH upsert AS + (UPDATE accounts SET balance = balance + 500 + WHERE accountid = 'savings' + RETURNING accountid) + INSERT INTO accounts SELECT 'savings', 500 + WHERE NOT EXISTS (SELECT 1 FROM upsert); + +step upsert2: + WITH upsert AS + (UPDATE accounts SET balance = balance + 1234 + WHERE accountid = 'savings' + RETURNING accountid) + INSERT INTO accounts SELECT 'savings', 1234 + WHERE NOT EXISTS (SELECT 1 FROM upsert); + <waiting ...> +step c1: COMMIT; +step upsert2: <... completed> +step c2: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 600 +savings | 2334 +(2 rows) + + +starting permutation: readp1 writep1 readp2 c1 c2 +step readp1: SELECT tableoid::regclass, ctid, * FROM p WHERE b IN (0, 1) AND c = 0 FOR UPDATE; +tableoid|ctid |a|b|c +--------+-----+-+-+- +c1 |(0,1)|0|0|0 +c1 |(0,4)|0|1|0 +c2 |(0,1)|1|0|0 +c2 |(0,4)|1|1|0 +c3 |(0,1)|2|0|0 +c3 |(0,4)|2|1|0 +(6 rows) + +step writep1: UPDATE p SET b = -1 WHERE a = 1 AND b = 1 AND c = 0; +step readp2: SELECT tableoid::regclass, ctid, * FROM p WHERE b IN (0, 1) AND c = 0 FOR UPDATE; <waiting ...> +step c1: COMMIT; +step readp2: <... completed> +tableoid|ctid |a|b|c +--------+-----+-+-+- +c1 |(0,1)|0|0|0 +c1 |(0,4)|0|1|0 +c2 |(0,1)|1|0|0 +c3 |(0,1)|2|0|0 +c3 |(0,4)|2|1|0 +(5 rows) + +step c2: COMMIT; + +starting permutation: writep2 returningp1 c1 c2 +step writep2: UPDATE p SET b = -b WHERE a = 1 AND c = 0; +step returningp1: + WITH u AS ( UPDATE p SET b = b WHERE a > 0 RETURNING * ) + SELECT * FROM u; + <waiting ...> +step c1: COMMIT; +step returningp1: <... completed> +a| b|c +-+--+- +1| 0|0 +1| 0|1 +1| 0|2 +1|-1|0 +1| 1|1 +1| 1|2 +1|-2|0 +1| 2|1 +1| 2|2 +1|-3|0 +2| 0|0 +2| 0|1 +2| 0|2 +2| 1|0 +2| 1|1 +2| 1|2 +2| 2|0 +2| 2|1 +2| 2|2 +2| 3|0 +(20 rows) + +step c2: COMMIT; + +starting permutation: writep3a writep3b c1 c2 +step writep3a: UPDATE p SET b = -b WHERE c = 0; +step writep3b: UPDATE p SET b = -b WHERE c = 0; <waiting ...> +step c1: COMMIT; +step writep3b: <... completed> +step c2: COMMIT; + +starting permutation: wx2 partiallock c2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step partiallock: + SELECT * FROM accounts a1, accounts a2 + WHERE a1.accountid = a2.accountid + FOR UPDATE OF a1; + <waiting ...> +step c2: COMMIT; +step partiallock: <... completed> +accountid|balance|accountid|balance +---------+-------+---------+------- +checking | 1050|checking | 600 +savings | 600|savings | 600 +(2 rows) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1050 +savings | 600 +(2 rows) + + +starting permutation: wx2 lockwithvalues c2 c1 read +step wx2: UPDATE accounts SET balance = balance + 450 WHERE accountid = 'checking' RETURNING balance; +balance +------- + 1050 +(1 row) + +step lockwithvalues: + -- Reference rowmark column that differs in type from targetlist at some attno. + -- See CAHU7rYZo_C4ULsAx_LAj8az9zqgrD8WDd4hTegDTMM1LMqrBsg@mail.gmail.com + SELECT a1.*, v.id FROM accounts a1, (values('checking'::text, 'nan'::text),('savings', 'nan')) v(id, notnumeric) + WHERE a1.accountid = v.id AND v.notnumeric != 'einszwei' + FOR UPDATE OF a1; + <waiting ...> +step c2: COMMIT; +step lockwithvalues: <... completed> +accountid|balance|id +---------+-------+-------- +checking | 1050|checking +savings | 600|savings +(2 rows) + +step c1: COMMIT; +step read: SELECT * FROM accounts ORDER BY accountid; +accountid|balance +---------+------- +checking | 1050 +savings | 600 +(2 rows) + + +starting permutation: wx2_ext partiallock_ext c2 c1 read_ext +step wx2_ext: UPDATE accounts_ext SET balance = balance + 450; +step partiallock_ext: + SELECT * FROM accounts_ext a1, accounts_ext a2 + WHERE a1.accountid = a2.accountid + FOR UPDATE OF a1; + <waiting ...> +step c2: COMMIT; +step partiallock_ext: <... completed> +accountid|balance|other|newcol|newcol2|accountid|balance|other|newcol|newcol2 +---------+-------+-----+------+-------+---------+-------+-----+------+------- +checking | 1050|other| 42| |checking | 600|other| 42| +savings | 1150| | 42| |savings | 700| | 42| +(2 rows) + +step c1: COMMIT; +step read_ext: SELECT * FROM accounts_ext ORDER BY accountid; +accountid|balance|other|newcol|newcol2 +---------+-------+-----+------+------- +checking | 1050|other| 42| +savings | 1150| | 42| +(2 rows) + + +starting permutation: updateforss readforss c1 c2 +step updateforss: + UPDATE table_a SET value = 'newTableAValue' WHERE id = 1; + UPDATE table_b SET value = 'newTableBValue' WHERE id = 1; + +step readforss: + SELECT ta.id AS ta_id, ta.value AS ta_value, + (SELECT ROW(tb.id, tb.value) + FROM table_b tb WHERE ta.id = tb.id) AS tb_row + FROM table_a ta + WHERE ta.id = 1 FOR UPDATE OF ta; + <waiting ...> +step c1: COMMIT; +step readforss: <... completed> +ta_id|ta_value |tb_row +-----+--------------+--------------- + 1|newTableAValue|(1,tableBValue) +(1 row) + +step c2: COMMIT; + +starting permutation: updateforcip updateforcip2 c1 c2 read_a +step updateforcip: + UPDATE table_a SET value = NULL WHERE id = 1; + +step updateforcip2: + UPDATE table_a SET value = COALESCE(value, (SELECT text 'newValue')) WHERE id = 1; + <waiting ...> +step c1: COMMIT; +step updateforcip2: <... completed> +step c2: COMMIT; +step read_a: SELECT * FROM table_a ORDER BY id; +id|value +--+-------- + 1|newValue +(1 row) + + +starting permutation: updateforcip updateforcip3 c1 c2 read_a +step updateforcip: + UPDATE table_a SET value = NULL WHERE id = 1; + +step updateforcip3: + WITH d(val) AS (SELECT text 'newValue' FROM generate_series(1,1)) + UPDATE table_a SET value = COALESCE(value, (SELECT val FROM d)) WHERE id = 1; + <waiting ...> +step c1: COMMIT; +step updateforcip3: <... completed> +step c2: COMMIT; +step read_a: SELECT * FROM table_a ORDER BY id; +id|value +--+-------- + 1|newValue +(1 row) + + +starting permutation: wrtwcte readwcte c1 c2 +step wrtwcte: UPDATE table_a SET value = 'tableAValue2' WHERE id = 1; +step readwcte: + WITH + cte1 AS ( + SELECT id FROM table_b WHERE value = 'tableBValue' + ), + cte2 AS ( + SELECT * FROM table_a + WHERE id = (SELECT id FROM cte1) + FOR UPDATE + ) + SELECT * FROM cte2; + <waiting ...> +step c1: COMMIT; +step c2: COMMIT; +step readwcte: <... completed> +id|value +--+------------ + 1|tableAValue2 +(1 row) + + +starting permutation: wrjt selectjoinforupdate c2 c1 +step wrjt: UPDATE jointest SET data = 42 WHERE id = 7; +step selectjoinforupdate: + set local enable_nestloop to 0; + set local enable_hashjoin to 0; + set local enable_seqscan to 0; + explain (costs off) + select * from jointest a join jointest b on a.id=b.id for update; + select * from jointest a join jointest b on a.id=b.id for update; + <waiting ...> +step c2: COMMIT; +step selectjoinforupdate: <... completed> +QUERY PLAN +---------------------------------------------------------- +LockRows + -> Merge Join + Merge Cond: (a.id = b.id) + -> Index Scan using jointest_id_idx on jointest a + -> Index Scan using jointest_id_idx on jointest b +(5 rows) + +id|data|id|data +--+----+--+---- + 1| 0| 1| 0 + 2| 0| 2| 0 + 3| 0| 3| 0 + 4| 0| 4| 0 + 5| 0| 5| 0 + 6| 0| 6| 0 + 7| 42| 7| 42 + 8| 0| 8| 0 + 9| 0| 9| 0 +10| 0|10| 0 +(10 rows) + +step c1: COMMIT; + +starting permutation: wrjt selectresultforupdate c2 c1 +step wrjt: UPDATE jointest SET data = 42 WHERE id = 7; +step selectresultforupdate: + select * from (select 1 as x) ss1 join (select 7 as y) ss2 on true + left join table_a a on a.id = x, jointest jt + where jt.id = y; + explain (verbose, costs off) + select * from (select 1 as x) ss1 join (select 7 as y) ss2 on true + left join table_a a on a.id = x, jointest jt + where jt.id = y for update of jt, ss1, ss2; + select * from (select 1 as x) ss1 join (select 7 as y) ss2 on true + left join table_a a on a.id = x, jointest jt + where jt.id = y for update of jt, ss1, ss2; + <waiting ...> +step c2: COMMIT; +step selectresultforupdate: <... completed> +x|y|id|value |id|data +-+-+--+-----------+--+---- +1|7| 1|tableAValue| 7| 0 +(1 row) + +QUERY PLAN +-------------------------------------------------------------------- +LockRows + Output: 1, 7, a.id, a.value, jt.id, jt.data, jt.ctid, a.ctid + -> Nested Loop Left Join + Output: 1, 7, a.id, a.value, jt.id, jt.data, jt.ctid, a.ctid + -> Nested Loop + Output: jt.id, jt.data, jt.ctid + -> Seq Scan on public.jointest jt + Output: jt.id, jt.data, jt.ctid + Filter: (jt.id = 7) + -> Result + -> Seq Scan on public.table_a a + Output: a.id, a.value, a.ctid + Filter: (a.id = 1) +(13 rows) + +x|y|id|value |id|data +-+-+--+-----------+--+---- +1|7| 1|tableAValue| 7| 42 +(1 row) + +step c1: COMMIT; + +starting permutation: wrtwcte multireadwcte c1 c2 +step wrtwcte: UPDATE table_a SET value = 'tableAValue2' WHERE id = 1; +step multireadwcte: + WITH updated AS ( + UPDATE table_a SET value = 'tableAValue3' WHERE id = 1 RETURNING id + ) + SELECT (SELECT id FROM updated) AS subid, * FROM updated; + <waiting ...> +step c1: COMMIT; +step c2: COMMIT; +step multireadwcte: <... completed> +subid|id +-----+-- + 1| 1 +(1 row) + + +starting permutation: simplepartupdate complexpartupdate c1 c2 +step simplepartupdate: + update parttbl set a = a; + +step complexpartupdate: + with u as (update parttbl set a = a returning parttbl.*) + update parttbl set a = u.a from u; + <waiting ...> +step c1: COMMIT; +step complexpartupdate: <... completed> +step c2: COMMIT; + +starting permutation: simplepartupdate_route1to2 complexpartupdate_route_err1 c1 c2 +step simplepartupdate_route1to2: + update parttbl set a = 2 where c = 1 returning *; + +a|b|c +-+-+- +2|1|1 +(1 row) + +step complexpartupdate_route_err1: + with u as (update another_parttbl set a = 1 returning another_parttbl.*) + update parttbl p set a = u.a from u where p.a = u.a and p.c = 1 returning p.*; + <waiting ...> +step c1: COMMIT; +step complexpartupdate_route_err1: <... completed> +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 +step simplepartupdate_noroute: + update parttbl set b = 2 where c = 1 returning *; + +a|b|c +-+-+- +1|2|1 +(1 row) + +step complexpartupdate_route: + with u as (update another_parttbl set a = 1 returning another_parttbl.*) + update parttbl p set a = p.b from u where p.a = u.a and p.c = 1 returning p.*; + <waiting ...> +step c1: COMMIT; +step complexpartupdate_route: <... completed> +a|b|c +-+-+- +2|2|1 +(1 row) + +step c2: COMMIT; + +starting permutation: simplepartupdate_noroute complexpartupdate_doesnt_route c1 c2 +step simplepartupdate_noroute: + update parttbl set b = 2 where c = 1 returning *; + +a|b|c +-+-+- +1|2|1 +(1 row) + +step complexpartupdate_doesnt_route: + with u as (update another_parttbl set a = 1 returning another_parttbl.*) + update parttbl p set a = 3 - p.b from u where p.a = u.a and p.c = 1 returning p.*; + <waiting ...> +step c1: COMMIT; +step complexpartupdate_doesnt_route: <... completed> +a|b|c +-+-+- +1|2|1 +(1 row) + +step c2: COMMIT; diff --git a/src/test/isolation/expected/fk-contention.out b/src/test/isolation/expected/fk-contention.out new file mode 100644 index 0000000..0916f7f --- /dev/null +++ b/src/test/isolation/expected/fk-contention.out @@ -0,0 +1,16 @@ +Parsed test spec with 2 sessions + +starting permutation: ins com upd +step ins: INSERT INTO bar VALUES (42); +step com: COMMIT; +step upd: UPDATE foo SET b = 'Hello World'; + +starting permutation: ins upd com +step ins: INSERT INTO bar VALUES (42); +step upd: UPDATE foo SET b = 'Hello World'; +step com: COMMIT; + +starting permutation: upd ins com +step upd: UPDATE foo SET b = 'Hello World'; +step ins: INSERT INTO bar VALUES (42); +step com: COMMIT; diff --git a/src/test/isolation/expected/fk-deadlock.out b/src/test/isolation/expected/fk-deadlock.out new file mode 100644 index 0000000..ce6ef8c --- /dev/null +++ b/src/test/isolation/expected/fk-deadlock.out @@ -0,0 +1,119 @@ +Parsed test spec with 2 sessions + +starting permutation: s1i s1u s1c s2i s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; + +starting permutation: s1i s1u s2i s1c s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2i: INSERT INTO child VALUES (2, 1); +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; + +starting permutation: s1i s1u s2i s2u s1c s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +step s2c: COMMIT; + +starting permutation: s1i s2i s1u s1c s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; + +starting permutation: s1i s2i s1u s2u s1c s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +step s2c: COMMIT; + +starting permutation: s1i s2i s2u s1u s2c s1c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; + +starting permutation: s1i s2i s2u s2c s1u s1c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; + +starting permutation: s2i s1i s1u s1c s2u s2c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; + +starting permutation: s2i s1i s1u s2u s1c s2c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +step s2c: COMMIT; + +starting permutation: s2i s1i s2u s1u s2c s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; + +starting permutation: s2i s1i s2u s2c s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; + +starting permutation: s2i s2u s1i s1u s2c s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; + +starting permutation: s2i s2u s1i s2c s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1i: INSERT INTO child VALUES (1, 1); +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; + +starting permutation: s2i s2u s2c s1i s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/fk-deadlock2.out b/src/test/isolation/expected/fk-deadlock2.out new file mode 100644 index 0000000..41a818d --- /dev/null +++ b/src/test/isolation/expected/fk-deadlock2.out @@ -0,0 +1,95 @@ +Parsed test spec with 2 sessions + +starting permutation: s1u1 s1u2 s1c s2u1 s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; + +starting permutation: s1u1 s1u2 s2u1 s1c s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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> +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; + +starting permutation: s1u1 s2u1 s1u2 s2u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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> +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s1u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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> +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s2c s1u2 s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s1u2 s2u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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> +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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> +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +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> +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s2c s1u1 s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/fk-deadlock2_1.out b/src/test/isolation/expected/fk-deadlock2_1.out new file mode 100644 index 0000000..e1d8c69 --- /dev/null +++ b/src/test/isolation/expected/fk-deadlock2_1.out @@ -0,0 +1,105 @@ +Parsed test spec with 2 sessions + +starting permutation: s1u1 s1u2 s1c s2u1 s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; + +starting permutation: s1u1 s1u2 s2u1 s1c s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: 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; + +starting permutation: s1u1 s2u1 s1u2 s2u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s1u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s2c s1u2 s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to read/write dependencies among transactions +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s1u2 s2u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to read/write dependencies among transactions +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to read/write dependencies among transactions +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s2c s1u1 s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/fk-deadlock2_2.out b/src/test/isolation/expected/fk-deadlock2_2.out new file mode 100644 index 0000000..9787370 --- /dev/null +++ b/src/test/isolation/expected/fk-deadlock2_2.out @@ -0,0 +1,105 @@ +Parsed test spec with 2 sessions + +starting permutation: s1u1 s1u2 s1c s2u1 s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; + +starting permutation: s1u1 s1u2 s2u1 s1c s2u2 s2c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: 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; + +starting permutation: s1u1 s2u1 s1u2 s2u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s1u2 s2c s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s1u1 s2u1 s2u2 s2c s1u2 s1c +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s1u2 s2u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s1u1 s2u2 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s1u2 s2c s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +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: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s1u1 s2c s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s2c: COMMIT; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2u1 s2u2 s2c s1u1 s1u2 s1c +step s2u1: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s2c: COMMIT; +step s1u1: UPDATE A SET Col1 = 1 WHERE AID = 1; +step s1u2: UPDATE B SET Col2 = 1 WHERE BID = 2; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/fk-deadlock_1.out b/src/test/isolation/expected/fk-deadlock_1.out new file mode 100644 index 0000000..c951692 --- /dev/null +++ b/src/test/isolation/expected/fk-deadlock_1.out @@ -0,0 +1,131 @@ +Parsed test spec with 2 sessions + +starting permutation: s1i s1u s1c s2i s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; + +starting permutation: s1i s1u s2i s1c s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2i: INSERT INTO child VALUES (2, 1); +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s1i s1u s2i s2u s1c s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s1i s2i s1u s1c s2u s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s1i s2i s1u s2u s1c s2c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s1i s2i s2u s1u s2c s1c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s1i s2i s2u s2c s1u s1c +step s1i: INSERT INTO child VALUES (1, 1); +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2i s1i s1u s1c s2u s2c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; +step s2u: UPDATE parent SET aux = 'baz'; +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s2i s1i s1u s2u s1c s2c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s2u: UPDATE parent SET aux = 'baz'; <waiting ...> +step s1c: COMMIT; +step s2u: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; + +starting permutation: s2i s1i s2u s1u s2c s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2i s1i s2u s2c s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s1i: INSERT INTO child VALUES (1, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2i s2u s1i s1u s2c s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2i s2u s1i s2c s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s1i: INSERT INTO child VALUES (1, 1); +step s2c: COMMIT; +step s1u: UPDATE parent SET aux = 'bar'; +ERROR: could not serialize access due to concurrent update +step s1c: COMMIT; + +starting permutation: s2i s2u s2c s1i s1u s1c +step s2i: INSERT INTO child VALUES (2, 1); +step s2u: UPDATE parent SET aux = 'baz'; +step s2c: COMMIT; +step s1i: INSERT INTO child VALUES (1, 1); +step s1u: UPDATE parent SET aux = 'bar'; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/fk-partitioned-1.out b/src/test/isolation/expected/fk-partitioned-1.out new file mode 100644 index 0000000..45f2f8c --- /dev/null +++ b/src/test/isolation/expected/fk-partitioned-1.out @@ -0,0 +1,133 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s1d s1c s2b s2a s2c +step s1b: begin; +step s1d: delete from ppk1 where a = 1; +step s1c: commit; +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s1b s1d s2b s1c s2a s2c +step s1b: begin; +step s1d: delete from ppk1 where a = 1; +step s2b: begin; +step s1c: commit; +step s2a: alter table pfk attach partition pfk1 for values in (1); +ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s1b s1d s2b s2a s1c s2c +step s1b: begin; +step s1d: delete from ppk1 where a = 1; +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); <waiting ...> +step s1c: commit; +step s2a: <... completed> +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 +step s1b: begin; +step s2b: begin; +step s1d: delete from ppk1 where a = 1; +step s1c: commit; +step s2a: alter table pfk attach partition pfk1 for values in (1); +ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s1b s2b s1d s2a s1c s2c +step s1b: begin; +step s2b: begin; +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: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s1b s2b s2a s1d s2c s1c +step s1b: begin; +step s2b: begin; +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: 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 +step s1b: begin; +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +step s2c: commit; +step s1d: delete from ppk1 where a = 1; +ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk" +step s1c: commit; + +starting permutation: s2b s1b s1d s1c s2a s2c +step s2b: begin; +step s1b: begin; +step s1d: delete from ppk1 where a = 1; +step s1c: commit; +step s2a: alter table pfk attach partition pfk1 for values in (1); +ERROR: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s2b s1b s1d s2a s1c s2c +step s2b: begin; +step s1b: begin; +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: insert or update on table "pfk1" violates foreign key constraint "pfk_a_fkey" +step s2c: commit; + +starting permutation: s2b s1b s2a s1d s2c s1c +step s2b: begin; +step s1b: begin; +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: 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 +step s2b: begin; +step s1b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +step s2c: commit; +step s1d: delete from ppk1 where a = 1; +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 s1d s2c s1c +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +step s1b: begin; +step s1d: delete from ppk1 where a = 1; <waiting ...> +step s2c: commit; +step s1d: <... completed> +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 +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +step s1b: begin; +step s2c: commit; +step s1d: delete from ppk1 where a = 1; +ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk" +step s1c: commit; + +starting permutation: s2b s2a s2c s1b s1d s1c +step s2b: begin; +step s2a: alter table pfk attach partition pfk1 for values in (1); +step s2c: commit; +step s1b: begin; +step s1d: delete from ppk1 where a = 1; +ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk" +step s1c: commit; diff --git a/src/test/isolation/expected/fk-partitioned-2.out b/src/test/isolation/expected/fk-partitioned-2.out new file mode 100644 index 0000000..8c6c714 --- /dev/null +++ b/src/test/isolation/expected/fk-partitioned-2.out @@ -0,0 +1,76 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s1d s2b s2i s1c s2c +step s1b: begin; +step s1d: delete from ppk where a = 1; +step s2b: begin; +step s2i: insert into pfk values (1); <waiting ...> +step s1c: commit; +step s2i: <... completed> +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 +step s1b: begin; +step s1d: delete from ppk where a = 1; +step s2bs: begin isolation level serializable; select 1; +?column? +-------- + 1 +(1 row) + +step s2i: insert into pfk values (1); <waiting ...> +step s1c: commit; +step s2i: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: commit; + +starting permutation: s1b s2b s1d s2i s1c s2c +step s1b: begin; +step s2b: begin; +step s1d: delete from ppk where a = 1; +step s2i: insert into pfk values (1); <waiting ...> +step s1c: commit; +step s2i: <... completed> +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 +step s1b: begin; +step s2bs: begin isolation level serializable; select 1; +?column? +-------- + 1 +(1 row) + +step s1d: delete from ppk where a = 1; +step s2i: insert into pfk values (1); <waiting ...> +step s1c: commit; +step s2i: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: commit; + +starting permutation: s1b s2b s2i s1d s2c s1c +step s1b: begin; +step s2b: begin; +step s2i: insert into pfk values (1); +step s1d: delete from ppk where a = 1; <waiting ...> +step s2c: commit; +step s1d: <... completed> +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 +step s1b: begin; +step s2bs: begin isolation level serializable; select 1; +?column? +-------- + 1 +(1 row) + +step s2i: insert into pfk values (1); +step s1d: delete from ppk where a = 1; <waiting ...> +step s2c: commit; +step s1d: <... completed> +ERROR: update or delete on table "ppk1" violates foreign key constraint "pfk_a_fkey1" on table "pfk" +step s1c: commit; diff --git a/src/test/isolation/expected/freeze-the-dead.out b/src/test/isolation/expected/freeze-the-dead.out new file mode 100644 index 0000000..88678bd --- /dev/null +++ b/src/test/isolation/expected/freeze-the-dead.out @@ -0,0 +1,44 @@ +Parsed test spec with 3 sessions + +starting permutation: s1_begin s2_begin s3_begin s1_update s2_key_share s3_key_share s1_update s1_commit s2_commit s2_vacuum s1_selectone s3_commit s2_vacuum s1_selectall +step s1_begin: BEGIN; +step s2_begin: BEGIN; +step s3_begin: BEGIN; +step s1_update: UPDATE tab_freeze SET x = x + 1 WHERE id = 3; +step s2_key_share: SELECT id FROM tab_freeze WHERE id = 3 FOR KEY SHARE; +id +-- + 3 +(1 row) + +step s3_key_share: SELECT id FROM tab_freeze WHERE id = 3 FOR KEY SHARE; +id +-- + 3 +(1 row) + +step s1_update: UPDATE tab_freeze SET x = x + 1 WHERE id = 3; +step s1_commit: COMMIT; +step s2_commit: COMMIT; +step s2_vacuum: VACUUM FREEZE tab_freeze; +step s1_selectone: + BEGIN; + SET LOCAL enable_seqscan = false; + SET LOCAL enable_bitmapscan = false; + SELECT * FROM tab_freeze WHERE id = 3; + COMMIT; + +id|name|x +--+----+- + 3| 333|2 +(1 row) + +step s3_commit: COMMIT; +step s2_vacuum: VACUUM FREEZE tab_freeze; +step s1_selectall: SELECT * FROM tab_freeze ORDER BY name, id; +id|name|x +--+----+- + 1| 111|0 + 3| 333|2 +(2 rows) + diff --git a/src/test/isolation/expected/index-only-scan.out b/src/test/isolation/expected/index-only-scan.out new file mode 100644 index 0000000..47983eb --- /dev/null +++ b/src/test/isolation/expected/index-only-scan.out @@ -0,0 +1,41 @@ +Parsed test spec with 2 sessions + +starting permutation: rxwy1 c1 rywx2 c2 +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step c1: COMMIT; +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step c2: COMMIT; + +starting permutation: rxwy1 rywx2 c1 c2 +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxwy1 rywx2 c2 c1 +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rywx2 rxwy1 c1 c2 +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rywx2 rxwy1 c2 c1 +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rywx2 c2 rxwy1 c1 +step rywx2: DELETE FROM tabx WHERE id = (SELECT min(id) FROM taby); +step c2: COMMIT; +step rxwy1: DELETE FROM taby WHERE id = (SELECT min(id) FROM tabx); +step c1: COMMIT; diff --git a/src/test/isolation/expected/inherit-temp.out b/src/test/isolation/expected/inherit-temp.out new file mode 100644 index 0000000..e6f0f22 --- /dev/null +++ b/src/test/isolation/expected/inherit-temp.out @@ -0,0 +1,277 @@ +Parsed test spec with 2 sessions + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_select_p: SELECT a FROM inh_parent; +a +- +1 +2 +3 +4 +(4 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +3 +4 +(2 rows) + +step s2_select_p: SELECT a FROM inh_parent; +a +- +1 +2 +5 +6 +(4 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +6 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_update_p s1_update_c s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_update_p: UPDATE inh_parent SET a = 11 WHERE a = 1; +step s1_update_c: UPDATE inh_parent SET a = 13 WHERE a IN (3, 5); +step s1_select_p: SELECT a FROM inh_parent; + a +-- + 2 +11 + 4 +13 +(4 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; + a +-- + 4 +13 +(2 rows) + +step s2_select_p: SELECT a FROM inh_parent; + a +-- + 2 +11 + 5 + 6 +(4 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +6 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s2_update_c s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s2_update_c: UPDATE inh_parent SET a = 15 WHERE a IN (3, 5); +step s1_select_p: SELECT a FROM inh_parent; +a +- +1 +2 +3 +4 +(4 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +3 +4 +(2 rows) + +step s2_select_p: SELECT a FROM inh_parent; + a +-- + 1 + 2 + 6 +15 +(4 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; + a +-- + 6 +15 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_delete_p s1_delete_c s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_delete_p: DELETE FROM inh_parent WHERE a = 2; +step s1_delete_c: DELETE FROM inh_parent WHERE a IN (4, 6); +step s1_select_p: SELECT a FROM inh_parent; +a +- +1 +3 +(2 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +3 +(1 row) + +step s2_select_p: SELECT a FROM inh_parent; +a +- +1 +5 +6 +(3 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +6 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s2_delete_c s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s2_delete_c: DELETE FROM inh_parent WHERE a IN (4, 6); +step s1_select_p: SELECT a FROM inh_parent; +a +- +1 +2 +3 +4 +(4 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +3 +4 +(2 rows) + +step s2_select_p: SELECT a FROM inh_parent; +a +- +1 +2 +5 +(3 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +(1 row) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_truncate_p s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_truncate_p: TRUNCATE inh_parent; +step s1_select_p: SELECT a FROM inh_parent; +a +- +(0 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +(0 rows) + +step s2_select_p: SELECT a FROM inh_parent; +a +- +5 +6 +(2 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +6 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s2_truncate_p s1_select_p s1_select_c s2_select_p s2_select_c +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s2_truncate_p: TRUNCATE inh_parent; +step s1_select_p: SELECT a FROM inh_parent; +a +- +3 +4 +(2 rows) + +step s1_select_c: SELECT a FROM inh_temp_child_s1; +a +- +3 +4 +(2 rows) + +step s2_select_p: SELECT a FROM inh_parent; +a +- +(0 rows) + +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +(0 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_begin s1_truncate_p s2_select_p s1_commit +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_begin: BEGIN; +step s1_truncate_p: TRUNCATE inh_parent; +step s2_select_p: SELECT a FROM inh_parent; <waiting ...> +step s1_commit: COMMIT; +step s2_select_p: <... completed> +a +- +5 +6 +(2 rows) + + +starting permutation: s1_insert_p s1_insert_c s2_insert_c s1_begin s1_truncate_p s2_select_c s1_commit +step s1_insert_p: INSERT INTO inh_parent VALUES (1), (2); +step s1_insert_c: INSERT INTO inh_temp_child_s1 VALUES (3), (4); +step s2_insert_c: INSERT INTO inh_temp_child_s2 VALUES (5), (6); +step s1_begin: BEGIN; +step s1_truncate_p: TRUNCATE inh_parent; +step s2_select_c: SELECT a FROM inh_temp_child_s2; +a +- +5 +6 +(2 rows) + +step s1_commit: COMMIT; diff --git a/src/test/isolation/expected/insert-conflict-do-nothing-2.out b/src/test/isolation/expected/insert-conflict-do-nothing-2.out new file mode 100644 index 0000000..22d41d3 --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-do-nothing-2.out @@ -0,0 +1,121 @@ +Parsed test spec with 2 sessions + +starting permutation: beginrr1 beginrr2 donothing1 c1 donothing2 c2 show +step beginrr1: BEGIN ISOLATION LEVEL REPEATABLE READ; +step beginrr2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step c1: COMMIT; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step c2: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing1 +(1 row) + + +starting permutation: beginrr1 beginrr2 donothing2 c2 donothing1 c1 show +step beginrr1: BEGIN ISOLATION LEVEL REPEATABLE READ; +step beginrr2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step c2: COMMIT; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step c1: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing2 +(1 row) + + +starting permutation: beginrr1 beginrr2 donothing1 donothing2 c1 c2 show +step beginrr1: BEGIN ISOLATION LEVEL REPEATABLE READ; +step beginrr2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; <waiting ...> +step c1: COMMIT; +step donothing2: <... completed> +ERROR: could not serialize access due to concurrent update +step c2: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing1 +(1 row) + + +starting permutation: beginrr1 beginrr2 donothing2 donothing1 c2 c1 show +step beginrr1: BEGIN ISOLATION LEVEL REPEATABLE READ; +step beginrr2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; <waiting ...> +step c2: COMMIT; +step donothing1: <... completed> +ERROR: could not serialize access due to concurrent update +step c1: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing2 +(1 row) + + +starting permutation: begins1 begins2 donothing1 c1 donothing2 c2 show +step begins1: BEGIN ISOLATION LEVEL SERIALIZABLE; +step begins2: BEGIN ISOLATION LEVEL SERIALIZABLE; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step c1: COMMIT; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step c2: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing1 +(1 row) + + +starting permutation: begins1 begins2 donothing2 c2 donothing1 c1 show +step begins1: BEGIN ISOLATION LEVEL SERIALIZABLE; +step begins2: BEGIN ISOLATION LEVEL SERIALIZABLE; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step c2: COMMIT; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step c1: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing2 +(1 row) + + +starting permutation: begins1 begins2 donothing1 donothing2 c1 c2 show +step begins1: BEGIN ISOLATION LEVEL SERIALIZABLE; +step begins2: BEGIN ISOLATION LEVEL SERIALIZABLE; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; <waiting ...> +step c1: COMMIT; +step donothing2: <... completed> +ERROR: could not serialize access due to concurrent update +step c2: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing1 +(1 row) + + +starting permutation: begins1 begins2 donothing2 donothing1 c2 c1 show +step begins1: BEGIN ISOLATION LEVEL SERIALIZABLE; +step begins2: BEGIN ISOLATION LEVEL SERIALIZABLE; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2'), (1, 'donothing3') ON CONFLICT DO NOTHING; +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; <waiting ...> +step c2: COMMIT; +step donothing1: <... completed> +ERROR: could not serialize access due to concurrent update +step c1: COMMIT; +step show: SELECT * FROM ints; +key|val +---+---------- + 1|donothing2 +(1 row) + diff --git a/src/test/isolation/expected/insert-conflict-do-nothing.out b/src/test/isolation/expected/insert-conflict-do-nothing.out new file mode 100644 index 0000000..cadf46d --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-do-nothing.out @@ -0,0 +1,27 @@ +Parsed test spec with 2 sessions + +starting permutation: donothing1 donothing2 c1 select2 c2 +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step c1: COMMIT; +step donothing2: <... completed> +step select2: SELECT * FROM ints; +key|val +---+---------- + 1|donothing1 +(1 row) + +step c2: COMMIT; + +starting permutation: donothing1 donothing2 a1 select2 c2 +step donothing1: INSERT INTO ints(key, val) VALUES(1, 'donothing1') ON CONFLICT DO NOTHING; +step donothing2: INSERT INTO ints(key, val) VALUES(1, 'donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step a1: ABORT; +step donothing2: <... completed> +step select2: SELECT * FROM ints; +key|val +---+---------- + 1|donothing2 +(1 row) + +step c2: COMMIT; diff --git a/src/test/isolation/expected/insert-conflict-do-update-2.out b/src/test/isolation/expected/insert-conflict-do-update-2.out new file mode 100644 index 0000000..7acd1ae --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-do-update-2.out @@ -0,0 +1,27 @@ +Parsed test spec with 2 sessions + +starting permutation: insert1 insert2 c1 select2 c2 +step insert1: INSERT INTO upsert(key, payload) VALUES('FooFoo', 'insert1') ON CONFLICT (lower(key)) DO UPDATE set key = EXCLUDED.key, payload = upsert.payload || ' updated by insert1'; +step insert2: INSERT INTO upsert(key, payload) VALUES('FOOFOO', 'insert2') ON CONFLICT (lower(key)) DO UPDATE set key = EXCLUDED.key, payload = upsert.payload || ' updated by insert2'; <waiting ...> +step c1: COMMIT; +step insert2: <... completed> +step select2: SELECT * FROM upsert; +key |payload +------+-------------------------- +FOOFOO|insert1 updated by insert2 +(1 row) + +step c2: COMMIT; + +starting permutation: insert1 insert2 a1 select2 c2 +step insert1: INSERT INTO upsert(key, payload) VALUES('FooFoo', 'insert1') ON CONFLICT (lower(key)) DO UPDATE set key = EXCLUDED.key, payload = upsert.payload || ' updated by insert1'; +step insert2: INSERT INTO upsert(key, payload) VALUES('FOOFOO', 'insert2') ON CONFLICT (lower(key)) DO UPDATE set key = EXCLUDED.key, payload = upsert.payload || ' updated by insert2'; <waiting ...> +step a1: ABORT; +step insert2: <... completed> +step select2: SELECT * FROM upsert; +key |payload +------+------- +FOOFOO|insert2 +(1 row) + +step c2: COMMIT; diff --git a/src/test/isolation/expected/insert-conflict-do-update-3.out b/src/test/isolation/expected/insert-conflict-do-update-3.out new file mode 100644 index 0000000..2d7e0b8 --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-do-update-3.out @@ -0,0 +1,30 @@ +Parsed test spec with 2 sessions + +starting permutation: update2 insert1 c2 select1surprise c1 +step update2: UPDATE colors SET is_active = true WHERE key = 1; +step insert1: + WITH t AS ( + INSERT INTO colors(key, color, is_active) + VALUES(1, 'Brown', true), (2, 'Gray', true) + ON CONFLICT (key) DO UPDATE + SET color = EXCLUDED.color + WHERE colors.is_active) + SELECT * FROM colors ORDER BY key; <waiting ...> +step c2: COMMIT; +step insert1: <... completed> +key|color|is_active +---+-----+--------- + 1|Red |f + 2|Green|f + 3|Blue |f +(3 rows) + +step select1surprise: SELECT * FROM colors ORDER BY key; +key|color|is_active +---+-----+--------- + 1|Brown|t + 2|Green|f + 3|Blue |f +(3 rows) + +step c1: COMMIT; diff --git a/src/test/isolation/expected/insert-conflict-do-update.out b/src/test/isolation/expected/insert-conflict-do-update.out new file mode 100644 index 0000000..16c384c --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-do-update.out @@ -0,0 +1,27 @@ +Parsed test spec with 2 sessions + +starting permutation: insert1 insert2 c1 select2 c2 +step insert1: INSERT INTO upsert(key, val) VALUES(1, 'insert1') ON CONFLICT (key) DO UPDATE set val = upsert.val || ' updated by insert1'; +step insert2: INSERT INTO upsert(key, val) VALUES(1, 'insert2') ON CONFLICT (key) DO UPDATE set val = upsert.val || ' updated by insert2'; <waiting ...> +step c1: COMMIT; +step insert2: <... completed> +step select2: SELECT * FROM upsert; +key|val +---+-------------------------- + 1|insert1 updated by insert2 +(1 row) + +step c2: COMMIT; + +starting permutation: insert1 insert2 a1 select2 c2 +step insert1: INSERT INTO upsert(key, val) VALUES(1, 'insert1') ON CONFLICT (key) DO UPDATE set val = upsert.val || ' updated by insert1'; +step insert2: INSERT INTO upsert(key, val) VALUES(1, 'insert2') ON CONFLICT (key) DO UPDATE set val = upsert.val || ' updated by insert2'; <waiting ...> +step a1: ABORT; +step insert2: <... completed> +step select2: SELECT * FROM upsert; +key|val +---+------- + 1|insert2 +(1 row) + +step c2: COMMIT; diff --git a/src/test/isolation/expected/insert-conflict-specconflict.out b/src/test/isolation/expected/insert-conflict-specconflict.out new file mode 100644 index 0000000..bb8f950 --- /dev/null +++ b/src/test/isolation/expected/insert-conflict-specconflict.out @@ -0,0 +1,553 @@ +Parsed test spec with 3 sessions + +starting permutation: controller_locks controller_show s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_2_2 controller_show controller_unlock_1_2 controller_show +step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); +pg_advisory_lock|sess|lock +----------------+----+---- + | 1| 1 + | 1| 2 + | 1| 3 + | 2| 1 + | 2| 2 + | 2| 3 +(6 rows) + +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 3 +step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; <waiting ...> +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 3 +step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; <waiting ...> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+----------- +k1 |inserted s2 +(1 row) + +step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step s1_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+----------------------------------- +k1 |inserted s2 with conflict update s1 +(1 row) + + +starting permutation: controller_locks controller_show s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show controller_unlock_2_2 controller_show +step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); +pg_advisory_lock|sess|lock +----------------+----+---- + | 1| 1 + | 1| 2 + | 1| 3 + | 2| 1 + | 2| 2 + | 2| 3 +(6 rows) + +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 3 +step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; <waiting ...> +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 3 +step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; <waiting ...> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+----------- +k1 |inserted s1 +(1 row) + +step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step s2_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+----------------------------------- +k1 |inserted s1 with conflict update s2 +(1 row) + + +starting permutation: controller_locks controller_show s1_insert_toast s2_insert_toast controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show_count controller_unlock_2_2 controller_show_count +step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); +pg_advisory_lock|sess|lock +----------------+----+---- + | 1| 1 + | 1| 2 + | 1| 3 + | 2| 1 + | 2| 2 + | 2| 3 +(6 rows) + +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +s1: NOTICE: blurt_and_lock_123() called for k2 in session 1 +s1: NOTICE: acquiring advisory lock on 3 +step s1_insert_toast: INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; <waiting ...> +s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 +s2: NOTICE: acquiring advisory lock on 3 +step s2_insert_toast: INSERT INTO upserttest VALUES('k2', ctoast_large_val()) ON CONFLICT DO NOTHING; <waiting ...> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k2 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_insert_toast: <... completed> +step controller_show_count: SELECT COUNT(*) FROM upserttest; +count +----- + 1 +(1 row) + +step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +s2: NOTICE: blurt_and_lock_123() called for k2 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step s2_insert_toast: <... completed> +step controller_show_count: SELECT COUNT(*) FROM upserttest; +count +----- + 1 +(1 row) + + +starting permutation: controller_locks controller_show s1_begin s2_begin s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_unlock_1_2 controller_show controller_unlock_2_2 controller_show s1_commit controller_show s2_commit controller_show +step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); +pg_advisory_lock|sess|lock +----------------+----+---- + | 1| 1 + | 1| 2 + | 1| 3 + | 2| 1 + | 2| 2 + | 2| 3 +(6 rows) + +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step s1_begin: BEGIN; +step s2_begin: BEGIN; +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 3 +step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; <waiting ...> +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 3 +step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; <waiting ...> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step s1_commit: COMMIT; +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step s2_upsert: <... completed> +step controller_show: SELECT * FROM upserttest; +key|data +---+----------- +k1 |inserted s1 +(1 row) + +step s2_commit: COMMIT; +step controller_show: SELECT * FROM upserttest; +key|data +---+----------------------------------- +k1 |inserted s1 with conflict update s2 +(1 row) + + +starting permutation: s1_create_non_unique_index s1_confirm_index_order controller_locks controller_show s2_begin s1_upsert s2_upsert controller_show controller_unlock_1_1 controller_unlock_2_1 controller_unlock_1_3 controller_unlock_2_3 controller_show controller_lock_2_4 controller_unlock_2_2 controller_show controller_unlock_1_2 controller_print_speculative_locks controller_unlock_2_4 s2_noop controller_print_speculative_locks s2_commit s1_noop controller_show controller_print_speculative_locks +step s1_create_non_unique_index: CREATE INDEX upserttest_key_idx ON upserttest((blurt_and_lock_4(key))); +step s1_confirm_index_order: SELECT 'upserttest_key_uniq_idx'::regclass::int8 < 'upserttest_key_idx'::regclass::int8; +?column? +-------- +t +(1 row) + +step controller_locks: SELECT pg_advisory_lock(sess, lock), sess, lock FROM generate_series(1, 2) a(sess), generate_series(1,3) b(lock); +pg_advisory_lock|sess|lock +----------------+----+---- + | 1| 1 + | 1| 2 + | 1| 3 + | 2| 1 + | 2| 2 + | 2| 3 +(6 rows) + +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step s2_begin: BEGIN; +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 3 +step s1_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s1') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s1'; <waiting ...> +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 3 +step s2_upsert: INSERT INTO upserttest(key, data) VALUES('k1', 'inserted s2') ON CONFLICT (blurt_and_lock_123(key)) DO UPDATE SET data = upserttest.data || ' with conflict update s2'; <waiting ...> +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_1: SELECT pg_advisory_unlock(1, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_2_1: SELECT pg_advisory_unlock(2, 1); +pg_advisory_unlock +------------------ +t +(1 row) + +step controller_unlock_1_3: SELECT pg_advisory_unlock(1, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_unlock_2_3: SELECT pg_advisory_unlock(2, 3); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_123() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 2 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_lock_2_4: SELECT pg_advisory_lock(2, 4); +pg_advisory_lock +---------------- + +(1 row) + +step controller_unlock_2_2: SELECT pg_advisory_unlock(2, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s2: NOTICE: blurt_and_lock_4() called for k1 in session 2 +s2: NOTICE: acquiring advisory lock on 4 +step controller_show: SELECT * FROM upserttest; +key|data +---+---- +(0 rows) + +step controller_unlock_1_2: SELECT pg_advisory_unlock(1, 2); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_4() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 4 +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step controller_print_speculative_locks: + SELECT pa.application_name, locktype, mode, granted + FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) + WHERE + locktype IN ('spectoken', 'transactionid') + AND pa.datname = current_database() + AND pa.application_name LIKE 'isolation/insert-conflict-specconflict-s%' + ORDER BY 1, 2, 3, 4; + +application_name |locktype |mode |granted +-----------------------------------------+-------------+-------------+------- +isolation/insert-conflict-specconflict-s1|spectoken |ShareLock |f +isolation/insert-conflict-specconflict-s1|transactionid|ExclusiveLock|t +isolation/insert-conflict-specconflict-s2|spectoken |ExclusiveLock|t +isolation/insert-conflict-specconflict-s2|transactionid|ExclusiveLock|t +(4 rows) + +step controller_unlock_2_4: SELECT pg_advisory_unlock(2, 4); +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step s2_upsert: <... completed> +step s2_noop: +step controller_print_speculative_locks: + SELECT pa.application_name, locktype, mode, granted + FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) + WHERE + locktype IN ('spectoken', 'transactionid') + AND pa.datname = current_database() + AND pa.application_name LIKE 'isolation/insert-conflict-specconflict-s%' + ORDER BY 1, 2, 3, 4; + +application_name |locktype |mode |granted +-----------------------------------------+-------------+-------------+------- +isolation/insert-conflict-specconflict-s1|transactionid|ExclusiveLock|t +isolation/insert-conflict-specconflict-s1|transactionid|ShareLock |f +isolation/insert-conflict-specconflict-s2|transactionid|ExclusiveLock|t +(3 rows) + +step s2_commit: COMMIT; +s1: NOTICE: blurt_and_lock_123() called for k1 in session 1 +s1: NOTICE: acquiring advisory lock on 2 +step s1_upsert: <... completed> +step s1_noop: +step controller_show: SELECT * FROM upserttest; +key|data +---+----------------------------------- +k1 |inserted s2 with conflict update s1 +(1 row) + +step controller_print_speculative_locks: + SELECT pa.application_name, locktype, mode, granted + FROM pg_locks pl JOIN pg_stat_activity pa USING (pid) + WHERE + locktype IN ('spectoken', 'transactionid') + AND pa.datname = current_database() + AND pa.application_name LIKE 'isolation/insert-conflict-specconflict-s%' + ORDER BY 1, 2, 3, 4; + +application_name|locktype|mode|granted +----------------+--------+----+------- +(0 rows) + diff --git a/src/test/isolation/expected/lock-committed-keyupdate.out b/src/test/isolation/expected/lock-committed-keyupdate.out new file mode 100644 index 0000000..7de6bc6 --- /dev/null +++ b/src/test/isolation/expected/lock-committed-keyupdate.out @@ -0,0 +1,670 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b1 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(578902068); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcku_table SET id = 2 WHERE id = 3; +step s1ul: SELECT pg_advisory_unlock(578902068); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcku_table WHERE pg_advisory_lock(578902068) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2l: <... completed> +ERROR: could not serialize access due to concurrent update +step s1hint: SELECT * FROM lcku_table; +id|value +--+----- + 1|one + 2|two +(2 rows) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + diff --git a/src/test/isolation/expected/lock-committed-update.out b/src/test/isolation/expected/lock-committed-update.out new file mode 100644 index 0000000..84b9ce7 --- /dev/null +++ b/src/test/isolation/expected/lock-committed-update.out @@ -0,0 +1,931 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b1 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s2l s1ul s1u s1c s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s2l s1ul s1u s1c s1hint s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b1 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b1: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1ul s1u s1c s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s2l s1ul s1u s1c s1hint s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b2 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b2: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1u s1c s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s2l s1c s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1ul s1u s1c s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1u s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s2l s1c s1hint s1ul s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s2l s1ul s1u s1c s1hint s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; <waiting ...> +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: <... completed> +id|value +--+----- + 1|one +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + + +starting permutation: s1b s2b3 s1l s1u s1ul s2l s1c s1hint s2c +step s1b: BEGIN; +step s2b3: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1l: SELECT pg_advisory_lock(380170116); +pg_advisory_lock +---------------- + +(1 row) + +step s1u: UPDATE lcu_table SET value = 'two' WHERE id = 1; +step s1ul: SELECT pg_advisory_unlock(380170116); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2l: SELECT * FROM lcu_table WHERE pg_advisory_lock(380170116) IS NOT NULL FOR KEY SHARE; +id|value +--+----- + 1|one +(1 row) + +step s1c: COMMIT; +step s1hint: SELECT * FROM lcu_table; +id|value +--+----- + 1|two +(1 row) + +step s2c: COMMIT; +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + diff --git a/src/test/isolation/expected/lock-update-delete.out b/src/test/isolation/expected/lock-update-delete.out new file mode 100644 index 0000000..f75e25f --- /dev/null +++ b/src/test/isolation/expected/lock-update-delete.out @@ -0,0 +1,285 @@ +Parsed test spec with 2 sessions + +starting permutation: s2b s1l s2u s2_blocker1 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2c: COMMIT; +step s1l: <... completed> +key|value +---+----- +(0 rows) + + +starting permutation: s2b s1l s2u s2_blocker2 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2c: COMMIT; +step s1l: <... completed> +key|value +---+----- +(0 rows) + + +starting permutation: s2b s1l s2u s2_blocker3 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s2b s1l s2u s2_blocker1 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2r: ROLLBACK; +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker2 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2r: ROLLBACK; +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker3 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2r: ROLLBACK; + +starting permutation: s2b s1l s2u s2_blocker1 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- +(0 rows) + + +starting permutation: s2b s1l s2u s2_blocker2 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- +(0 rows) + + +starting permutation: s2b s1l s2u s2_blocker3 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker1 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker2 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker3 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + diff --git a/src/test/isolation/expected/lock-update-delete_1.out b/src/test/isolation/expected/lock-update-delete_1.out new file mode 100644 index 0000000..c602ac8 --- /dev/null +++ b/src/test/isolation/expected/lock-update-delete_1.out @@ -0,0 +1,273 @@ +Parsed test spec with 2 sessions + +starting permutation: s2b s1l s2u s2_blocker1 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2c: COMMIT; +step s1l: <... completed> +ERROR: could not serialize access due to concurrent update + +starting permutation: s2b s1l s2u s2_blocker2 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2c: COMMIT; +step s1l: <... completed> +ERROR: could not serialize access due to concurrent update + +starting permutation: s2b s1l s2u s2_blocker3 s2_unlock s2c +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; + +starting permutation: s2b s1l s2u s2_blocker1 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2r: ROLLBACK; +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker2 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s2r: ROLLBACK; +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker3 s2_unlock s2r +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + +step s2r: ROLLBACK; + +starting permutation: s2b s1l s2u s2_blocker1 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +ERROR: could not serialize access due to concurrent update + +starting permutation: s2b s1l s2u s2_blocker2 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +ERROR: could not serialize access due to concurrent update + +starting permutation: s2b s1l s2u s2_blocker3 s2c s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2c: COMMIT; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker1 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker1: DELETE FROM foo; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker2 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker2: UPDATE foo SET key = 2 WHERE key = 1; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + + +starting permutation: s2b s1l s2u s2_blocker3 s2r s2_unlock +pg_advisory_lock +---------------- + +(1 row) + +step s2b: BEGIN; +step s1l: SELECT * FROM foo WHERE pg_advisory_xact_lock(0) IS NOT NULL AND key = 1 FOR KEY SHARE; <waiting ...> +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s2_blocker3: UPDATE foo SET value = 2 WHERE key = 1; +step s2r: ROLLBACK; +step s2_unlock: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1l: <... completed> +key|value +---+----- + 1| 1 +(1 row) + diff --git a/src/test/isolation/expected/lock-update-traversal.out b/src/test/isolation/expected/lock-update-traversal.out new file mode 100644 index 0000000..6d6a97d --- /dev/null +++ b/src/test/isolation/expected/lock-update-traversal.out @@ -0,0 +1,63 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b s1s s2u s1l s2c s2d1 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN; +step s1s: SELECT * FROM foo; +key|value +---+----- + 1| 1 +(1 row) + +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s2d1: DELETE FROM foo WHERE key = 1; <waiting ...> +step s1c: COMMIT; +step s2d1: <... completed> + +starting permutation: s1b s2b s1s s2u s1l s2c s2d2 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN; +step s1s: SELECT * FROM foo; +key|value +---+----- + 1| 1 +(1 row) + +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s2d2: UPDATE foo SET key = 3 WHERE key = 1; <waiting ...> +step s1c: COMMIT; +step s2d2: <... completed> + +starting permutation: s1b s2b s1s s2u s1l s2c s2d3 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN; +step s1s: SELECT * FROM foo; +key|value +---+----- + 1| 1 +(1 row) + +step s2u: UPDATE foo SET value = 2 WHERE key = 1; +step s1l: SELECT * FROM foo FOR KEY SHARE; +key|value +---+----- + 1| 1 +(1 row) + +step s2c: COMMIT; +step s2d3: UPDATE foo SET value = 3 WHERE key = 1; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/multiple-cic.out b/src/test/isolation/expected/multiple-cic.out new file mode 100644 index 0000000..7a0f326 --- /dev/null +++ b/src/test/isolation/expected/multiple-cic.out @@ -0,0 +1,24 @@ +Parsed test spec with 2 sessions + +starting permutation: s2l s1i s2i +step s2l: SELECT pg_advisory_lock(281457); +pg_advisory_lock +---------------- + +(1 row) + +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 +(1 row) + diff --git a/src/test/isolation/expected/multiple-row-versions.out b/src/test/isolation/expected/multiple-row-versions.out new file mode 100644 index 0000000..79f492e --- /dev/null +++ b/src/test/isolation/expected/multiple-row-versions.out @@ -0,0 +1,30 @@ +Parsed test spec with 4 sessions + +starting permutation: rx1 wx2 c2 wx3 ry3 wy4 rz4 c4 c3 wz1 c1 +step rx1: SELECT * FROM t WHERE id = 1000000; + id|txt +-------+--- +1000000| +(1 row) + +step wx2: UPDATE t SET txt = 'b' WHERE id = 1000000; +step c2: COMMIT; +step wx3: UPDATE t SET txt = 'c' WHERE id = 1000000; +step ry3: SELECT * FROM t WHERE id = 500000; + id|txt +------+--- +500000| +(1 row) + +step wy4: UPDATE t SET txt = 'd' WHERE id = 500000; +step rz4: SELECT * FROM t WHERE id = 1; +id|txt +--+--- + 1| +(1 row) + +step c4: COMMIT; +step c3: COMMIT; +step wz1: UPDATE t SET txt = 'a' WHERE id = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; diff --git a/src/test/isolation/expected/multixact-no-deadlock.out b/src/test/isolation/expected/multixact-no-deadlock.out new file mode 100644 index 0000000..4b9ce7b --- /dev/null +++ b/src/test/isolation/expected/multixact-no-deadlock.out @@ -0,0 +1,32 @@ +Parsed test spec with 3 sessions + +starting permutation: s1lock s2lock s1svpt s3lock s1lock2 s2c s1c s3c +step s1lock: SELECT * FROM justthis FOR SHARE; +value +----- + 1 +(1 row) + +step s2lock: SELECT * FROM justthis FOR SHARE; +value +----- + 1 +(1 row) + +step s1svpt: SAVEPOINT foo; +step s3lock: SELECT * FROM justthis FOR UPDATE; <waiting ...> +step s1lock2: SELECT * FROM justthis FOR SHARE; +value +----- + 1 +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; +step s3lock: <... completed> +value +----- + 1 +(1 row) + +step s3c: COMMIT; diff --git a/src/test/isolation/expected/multixact-no-forget.out b/src/test/isolation/expected/multixact-no-forget.out new file mode 100644 index 0000000..ce06b38 --- /dev/null +++ b/src/test/isolation/expected/multixact-no-forget.out @@ -0,0 +1,168 @@ +Parsed test spec with 3 sessions + +starting permutation: s1_show s1_commit s2_commit +step s1_show: SELECT current_setting('default_transaction_isolation') <> 'read committed'; +?column? +-------- +f +(1 row) + +step s1_commit: COMMIT; +step s2_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_abort s3_forkeyshr s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_commit s3_forkeyshr s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 2 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s1_commit s3_forkeyshr s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_abort s3_fornokeyupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; +value +----- + 1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_commit s3_fornokeyupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; +value +----- + 2 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s1_commit s3_fornokeyupd s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; <waiting ...> +step s2_commit: COMMIT; +step s3_fornokeyupd: <... completed> +value +----- + 2 +(1 row) + + +starting permutation: s1_lock s2_update s2_abort s3_forupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s3_forupd: <... completed> +value +----- + 1 +(1 row) + + +starting permutation: s1_lock s2_update s2_commit s3_forupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s3_forupd: <... completed> +value +----- + 2 +(1 row) + + +starting permutation: s1_lock s2_update s1_commit s3_forupd s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s2_commit: COMMIT; +step s3_forupd: <... completed> +value +----- + 2 +(1 row) + diff --git a/src/test/isolation/expected/multixact-no-forget_1.out b/src/test/isolation/expected/multixact-no-forget_1.out new file mode 100644 index 0000000..f15a1e1 --- /dev/null +++ b/src/test/isolation/expected/multixact-no-forget_1.out @@ -0,0 +1,160 @@ +Parsed test spec with 3 sessions + +starting permutation: s1_show s1_commit s2_commit +step s1_show: SELECT current_setting('default_transaction_isolation') <> 'read committed'; +?column? +-------- +t +(1 row) + +step s1_commit: COMMIT; +step s2_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_abort s3_forkeyshr s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_commit s3_forkeyshr s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 2 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s1_commit s3_forkeyshr s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_forkeyshr: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_abort s3_fornokeyupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; +value +----- + 1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s2_commit s3_fornokeyupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; +value +----- + 2 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_lock s2_update s1_commit s3_fornokeyupd s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_fornokeyupd: SELECT * FROM dont_forget FOR NO KEY UPDATE; <waiting ...> +step s2_commit: COMMIT; +step s3_fornokeyupd: <... completed> +ERROR: could not serialize access due to concurrent update + +starting permutation: s1_lock s2_update s2_abort s3_forupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_abort: ROLLBACK; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s3_forupd: <... completed> +value +----- + 1 +(1 row) + + +starting permutation: s1_lock s2_update s2_commit s3_forupd s1_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s2_commit: COMMIT; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s3_forupd: <... completed> +value +----- + 2 +(1 row) + + +starting permutation: s1_lock s2_update s1_commit s3_forupd s2_commit +step s1_lock: SELECT * FROM dont_forget FOR KEY SHARE; +value +----- + 1 +(1 row) + +step s2_update: UPDATE dont_forget SET value = 2; +step s1_commit: COMMIT; +step s3_forupd: SELECT * FROM dont_forget FOR UPDATE; <waiting ...> +step s2_commit: COMMIT; +step s3_forupd: <... completed> +ERROR: could not serialize access due to concurrent update diff --git a/src/test/isolation/expected/nowait-2.out b/src/test/isolation/expected/nowait-2.out new file mode 100644 index 0000000..ba18fa7 --- /dev/null +++ b/src/test/isolation/expected/nowait-2.out @@ -0,0 +1,55 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s2a s2b s1b s2c +step s1a: SELECT * FROM foo FOR SHARE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2a: SELECT * FROM foo FOR SHARE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2b: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c +step s2a: SELECT * FROM foo FOR SHARE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1a: SELECT * FROM foo FOR SHARE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2b: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c +step s2a: SELECT * FROM foo FOR SHARE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2b: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1a: SELECT * FROM foo FOR SHARE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2c: COMMIT; diff --git a/src/test/isolation/expected/nowait-3.out b/src/test/isolation/expected/nowait-3.out new file mode 100644 index 0000000..19a5b68 --- /dev/null +++ b/src/test/isolation/expected/nowait-3.out @@ -0,0 +1,21 @@ +Parsed test spec with 3 sessions + +starting permutation: s1a s2a s3a s1b s2b s3b +step s1a: SELECT * FROM foo FOR UPDATE; +id|data +--+---- + 1|x +(1 row) + +step s2a: SELECT * FROM foo FOR UPDATE; <waiting ...> +step s3a: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2a: <... completed> +id|data +--+---- + 1|x +(1 row) + +step s2b: COMMIT; +step s3b: COMMIT; diff --git a/src/test/isolation/expected/nowait-4.out b/src/test/isolation/expected/nowait-4.out new file mode 100644 index 0000000..be0edbd --- /dev/null +++ b/src/test/isolation/expected/nowait-4.out @@ -0,0 +1,23 @@ +Parsed test spec with 2 sessions + +starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f +step s2a: SELECT pg_advisory_lock(0); +pg_advisory_lock +---------------- + +(1 row) + +step s1a: SELECT * FROM foo WHERE pg_advisory_lock(0) IS NOT NULL FOR UPDATE NOWAIT; <waiting ...> +step s2b: UPDATE foo SET data = data; +step s2c: BEGIN; +step s2d: UPDATE foo SET data = data; +step s2e: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1a: <... completed> +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2f: COMMIT; diff --git a/src/test/isolation/expected/nowait-4_1.out b/src/test/isolation/expected/nowait-4_1.out new file mode 100644 index 0000000..05e2fcf --- /dev/null +++ b/src/test/isolation/expected/nowait-4_1.out @@ -0,0 +1,23 @@ +Parsed test spec with 2 sessions + +starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f +step s2a: SELECT pg_advisory_lock(0); +pg_advisory_lock +---------------- + +(1 row) + +step s1a: SELECT * FROM foo WHERE pg_advisory_lock(0) IS NOT NULL FOR UPDATE NOWAIT; <waiting ...> +step s2b: UPDATE foo SET data = data; +step s2c: BEGIN; +step s2d: UPDATE foo SET data = data; +step s2e: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1a: <... completed> +ERROR: could not serialize access due to concurrent update +step s1b: COMMIT; +step s2f: COMMIT; diff --git a/src/test/isolation/expected/nowait-5.out b/src/test/isolation/expected/nowait-5.out new file mode 100644 index 0000000..f1aae21 --- /dev/null +++ b/src/test/isolation/expected/nowait-5.out @@ -0,0 +1,43 @@ +Parsed test spec with 3 sessions + +starting permutation: sl1_prep upd_getlock sl1_exec upd_doupdate lk1_doforshare upd_releaselock +step sl1_prep: + PREPARE sl1_run AS SELECT id FROM test_nowait WHERE pg_advisory_lock(0) is not null FOR UPDATE NOWAIT; + +step upd_getlock: + SELECT pg_advisory_lock(0); + +pg_advisory_lock +---------------- + +(1 row) + +step sl1_exec: + BEGIN ISOLATION LEVEL READ COMMITTED; + EXECUTE sl1_run; + SELECT xmin, xmax, ctid, * FROM test_nowait; + <waiting ...> +step upd_doupdate: + BEGIN ISOLATION LEVEL READ COMMITTED; + UPDATE test_nowait SET value = value WHERE id % 2 = 0; + COMMIT; + +step lk1_doforshare: + BEGIN ISOLATION LEVEL READ COMMITTED; + SELECT id FROM test_nowait WHERE id % 2 = 0 FOR SHARE; + +id +-- + 2 +(1 row) + +step upd_releaselock: + SELECT pg_advisory_unlock(0); + +pg_advisory_unlock +------------------ +t +(1 row) + +step sl1_exec: <... completed> +ERROR: could not obtain lock on row in relation "test_nowait" diff --git a/src/test/isolation/expected/nowait.out b/src/test/isolation/expected/nowait.out new file mode 100644 index 0000000..ea1cdf0 --- /dev/null +++ b/src/test/isolation/expected/nowait.out @@ -0,0 +1,81 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s1b s2a s2b +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1b: COMMIT; +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2b: COMMIT; + +starting permutation: s1a s2a s1b s2b +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2b: COMMIT; + +starting permutation: s1a s2a s2b s1b +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s2b: COMMIT; +step s1b: COMMIT; + +starting permutation: s2a s1a s1b s2b +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s1b: COMMIT; +step s2b: COMMIT; + +starting permutation: s2a s1a s2b s1b +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +ERROR: could not obtain lock on row in relation "foo" +step s2b: COMMIT; +step s1b: COMMIT; + +starting permutation: s2a s2b s1a s1b +step s2a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s2b: COMMIT; +step s1a: SELECT * FROM foo FOR UPDATE NOWAIT; +id|data +--+---- + 1|x +(1 row) + +step s1b: COMMIT; diff --git a/src/test/isolation/expected/partial-index.out b/src/test/isolation/expected/partial-index.out new file mode 100644 index 0000000..d6cae90 --- /dev/null +++ b/src/test/isolation/expected/partial-index.out @@ -0,0 +1,715 @@ +Parsed test spec with 2 sessions + +starting permutation: rxy1 wx1 c1 wy2 rxy2 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +(9 rows) + +step c2: COMMIT; + +starting permutation: rxy1 wx1 wy2 c1 rxy2 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step c1: COMMIT; +step rxy2: select * from test_t where val2 = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rxy1 wx1 wy2 rxy2 c1 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wx1 wy2 rxy2 c2 c1 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wy2 wx1 c1 rxy2 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step rxy2: select * from test_t where val2 = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rxy1 wy2 wx1 rxy2 c1 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wy2 wx1 rxy2 c2 c1 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wy2 rxy2 wx1 c1 c2 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wy2 rxy2 wx1 c2 c1 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wy2 rxy2 c2 wx1 c1 +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 rxy1 wx1 c1 rxy2 c2 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step rxy2: select * from test_t where val2 = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: wy2 rxy1 wx1 rxy2 c1 c2 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy1 wx1 rxy2 c2 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy1 rxy2 wx1 c1 c2 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy1 rxy2 wx1 c2 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy1 rxy2 c2 wx1 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 rxy2 rxy1 wx1 c1 c2 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy2 rxy1 wx1 c2 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy2 rxy1 c2 wx1 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 + 9|a | 1 +10|a | 1 +(11 rows) + +step c2: COMMIT; +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 rxy2 c2 rxy1 wx1 c1 +step wy2: update test_t set val2 = 2 where val2 = 1 and id = 9; +step rxy2: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step c2: COMMIT; +step rxy1: select * from test_t where val2 = 1; +id|val1|val2 +--+----+---- + 0|a | 1 + 1|a | 1 + 2|a | 1 + 3|a | 1 + 4|a | 1 + 5|a | 1 + 6|a | 1 + 7|a | 1 + 8|a | 1 +10|a | 1 +(10 rows) + +step wx1: update test_t set val2 = 2 where val2 = 1 and id = 10; +step c1: COMMIT; diff --git a/src/test/isolation/expected/partition-concurrent-attach.out b/src/test/isolation/expected/partition-concurrent-attach.out new file mode 100644 index 0000000..53775f4 --- /dev/null +++ b/src/test/isolation/expected/partition-concurrent-attach.out @@ -0,0 +1,55 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s1a s2b s2i s1c s2c s2s +step s1b: begin; +step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); +step s2b: begin; +step s2i: insert into tpart values (110,'xxx'), (120, 'yyy'), (150, 'zzz'); <waiting ...> +step s1c: commit; +step s2i: <... completed> +ERROR: new row for relation "tpart_default" violates partition constraint +step s2c: commit; +step s2s: select tableoid::regclass, * from tpart; +tableoid| i|j +--------+---+--- +tpart_2 |110|xxx +tpart_2 |120|yyy +tpart_2 |150|zzz +(3 rows) + + +starting permutation: s1b s1a s2b s2i2 s1c s2c s2s +step s1b: begin; +step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); +step s2b: begin; +step s2i2: insert into tpart_default (i, j) values (110, 'xxx'), (120, 'yyy'), (150, 'zzz'); <waiting ...> +step s1c: commit; +step s2i2: <... completed> +ERROR: new row for relation "tpart_default" violates partition constraint +step s2c: commit; +step s2s: select tableoid::regclass, * from tpart; +tableoid| i|j +--------+---+--- +tpart_2 |110|xxx +tpart_2 |120|yyy +tpart_2 |150|zzz +(3 rows) + + +starting permutation: s1b s2b s2i s1a s2c s1c s2s +step s1b: begin; +step s2b: begin; +step s2i: insert into tpart values (110,'xxx'), (120, 'yyy'), (150, 'zzz'); +step s1a: alter table tpart attach partition tpart_2 for values from (100) to (200); <waiting ...> +step s2c: commit; +step s1a: <... completed> +ERROR: updated partition constraint for default partition "tpart_default_default" would be violated by some row +step s1c: commit; +step s2s: select tableoid::regclass, * from tpart; +tableoid | i|j +---------------------+---+--- +tpart_default_default|110|xxx +tpart_default_default|120|yyy +tpart_default_default|150|zzz +(3 rows) + diff --git a/src/test/isolation/expected/partition-key-update-1.out b/src/test/isolation/expected/partition-key-update-1.out new file mode 100644 index 0000000..7dee144 --- /dev/null +++ b/src/test/isolation/expected/partition-key-update-1.out @@ -0,0 +1,129 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b s1u s1c s2d s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u: UPDATE foo SET a=2 WHERE a=1; +step s1c: COMMIT; +step s2d: DELETE FROM foo WHERE a=1; +step s2c: COMMIT; + +starting permutation: s1b s2b s1u s2d s1c s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2d: DELETE FROM foo WHERE a=1; +step s1u: UPDATE foo SET a=2 WHERE a=1; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; + +starting permutation: s1b s2b s1u2 s1c s2u2 s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u2: UPDATE footrg SET b='EFG' WHERE a=1; +step s1c: COMMIT; +step s2u2: UPDATE footrg SET b='XYZ' WHERE a=1; +step s2c: COMMIT; + +starting permutation: s1b s2b s1u2 s2u2 s1c s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7; +step s2i: INSERT INTO bar VALUES(7); <waiting ...> +step s1r: ROLLBACK; +step s2i: <... completed> +step s2c: COMMIT; + +starting permutation: s1b s2b s1u3npc s1u3pc s2i s1c s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u3npc: UPDATE foo_range_parted SET b='XYZ' WHERE a=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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u3npc: UPDATE foo_range_parted SET b='XYZ' WHERE a=7; +step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7; +step s2i: INSERT INTO bar VALUES(7); <waiting ...> +step s1r: ROLLBACK; +step s2i: <... completed> +step s2c: COMMIT; + +starting permutation: s1b s2b s1u3npc s1u3pc s1u3pc s2i s1c s2c +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u3npc: UPDATE foo_range_parted SET b='XYZ' WHERE a=7; +step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=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: 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 +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s1u3npc: UPDATE foo_range_parted SET b='XYZ' WHERE a=7; +step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7; +step s1u3pc: UPDATE foo_range_parted SET a=11 WHERE a=7; +step s2i: INSERT INTO bar VALUES(7); <waiting ...> +step s1r: ROLLBACK; +step s2i: <... completed> +step s2c: COMMIT; diff --git a/src/test/isolation/expected/partition-key-update-2.out b/src/test/isolation/expected/partition-key-update-2.out new file mode 100644 index 0000000..f054de5 --- /dev/null +++ b/src/test/isolation/expected/partition-key-update-2.out @@ -0,0 +1,33 @@ +Parsed test spec with 3 sessions + +starting permutation: s1u s2donothing s3donothing s1c s2c s3select s3c +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s2donothing: <... completed> +step s3donothing: <... completed> +step s2c: COMMIT; +step s3select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + +step s3c: COMMIT; + +starting permutation: s2donothing s1u s3donothing s1c s2c s3select s3c +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; +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') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s3donothing: <... completed> +step s2c: COMMIT; +step s3select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +2|initial tuple -> moved by session-1 +(1 row) + +step s3c: COMMIT; diff --git a/src/test/isolation/expected/partition-key-update-3.out b/src/test/isolation/expected/partition-key-update-3.out new file mode 100644 index 0000000..b5872b8 --- /dev/null +++ b/src/test/isolation/expected/partition-key-update-3.out @@ -0,0 +1,155 @@ +Parsed test spec with 3 sessions + +starting permutation: s2beginrr s3beginrr s1u s2donothing s1c s2c s3donothing s3c s2select +step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s2donothing: <... completed> +step s2c: COMMIT; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; +step s3c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2beginrr s3beginrr s1u s3donothing s1c s3c s2donothing s2c s2select +step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s3donothing: <... completed> +ERROR: could not serialize access due to concurrent update +step s3c: COMMIT; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; +step s2c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2beginrr s3beginrr s1u s2donothing s3donothing s1c s2c s3c s2select +step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s2donothing: <... completed> +step s3donothing: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +step s3c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2beginrr s3beginrr s1u s3donothing s2donothing s1c s3c s2c s2select +step s2beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s3beginrr: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +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> +step s3c: COMMIT; +step s2c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2begins s3begins s1u s2donothing s1c s2c s3donothing s3c s2select +step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s2donothing: <... completed> +step s2c: COMMIT; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; +step s3c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2begins s3begins s1u s3donothing s1c s3c s2donothing s2c s2select +step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s3donothing: <... completed> +ERROR: could not serialize access due to concurrent update +step s3c: COMMIT; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; +step s2c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2begins s3begins s1u s2donothing s3donothing s1c s2c s3c s2select +step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s2donothing: INSERT INTO foo VALUES(1, 'session-2 donothing') ON CONFLICT DO NOTHING; <waiting ...> +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +step s1c: COMMIT; +step s2donothing: <... completed> +step s3donothing: <... completed> +ERROR: could not serialize access due to concurrent update +step s2c: COMMIT; +step s3c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + + +starting permutation: s2begins s3begins s1u s3donothing s2donothing s1c s3c s2c s2select +step s2begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s3begins: BEGIN ISOLATION LEVEL SERIALIZABLE; +step s1u: UPDATE foo SET a=2, b=b || ' -> moved by session-1' WHERE a=1; +step s3donothing: INSERT INTO foo VALUES(2, 'session-3 donothing'), (2, 'session-3 donothing2') ON CONFLICT DO NOTHING; <waiting ...> +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> +step s3c: COMMIT; +step s2c: COMMIT; +step s2select: SELECT * FROM foo ORDER BY a; +a|b +-+----------------------------------- +1|session-2 donothing +2|initial tuple -> moved by session-1 +(2 rows) + diff --git a/src/test/isolation/expected/partition-key-update-4.out b/src/test/isolation/expected/partition-key-update-4.out new file mode 100644 index 0000000..91fa041 --- /dev/null +++ b/src/test/isolation/expected/partition-key-update-4.out @@ -0,0 +1,72 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b s2u1 s1u s2c s1c s1s +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2u1: UPDATE foo SET b = b || ' update2' WHERE a = 1; +step s1u: UPDATE foo SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; +step s1s: SELECT tableoid::regclass, * FROM foo ORDER BY a; +tableoid|a|b +--------+-+------------------- +foo2 |2|ABC update2 update1 +(1 row) + + +starting permutation: s1b s2b s2ut1 s1ut s2c s1c s1st s1stl +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2ut1: UPDATE footrg SET b = b || ' update2' WHERE a = 1; +step s1ut: UPDATE footrg SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; <waiting ...> +step s2c: COMMIT; +step s1ut: <... completed> +step s1c: COMMIT; +step s1st: SELECT tableoid::regclass, * FROM footrg ORDER BY a; +tableoid|a|b +--------+-+------------------- +footrg2 |2|ABC update2 update1 +(1 row) + +step s1stl: SELECT * FROM triglog ORDER BY a; +a|b +-+------------------- +1|ABC update2 trigger +(1 row) + + +starting permutation: s1b s2b s2u2 s1u s2c s1c s1s +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2u2: UPDATE foo SET b = 'EFG' WHERE a = 1; +step s1u: UPDATE foo SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; <waiting ...> +step s2c: COMMIT; +step s1u: <... completed> +step s1c: COMMIT; +step s1s: SELECT tableoid::regclass, * FROM foo ORDER BY a; +tableoid|a|b +--------+-+--- +foo1 |1|EFG +(1 row) + + +starting permutation: s1b s2b s2ut2 s1ut s2c s1c s1st s1stl +step s1b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2b: BEGIN ISOLATION LEVEL READ COMMITTED; +step s2ut2: UPDATE footrg SET b = 'EFG' WHERE a = 1; +step s1ut: UPDATE footrg SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; <waiting ...> +step s2c: COMMIT; +step s1ut: <... completed> +step s1c: COMMIT; +step s1st: SELECT tableoid::regclass, * FROM footrg ORDER BY a; +tableoid|a|b +--------+-+--- +footrg1 |1|EFG +(1 row) + +step s1stl: SELECT * FROM triglog ORDER BY a; +a|b +-+- +(0 rows) + diff --git a/src/test/isolation/expected/plpgsql-toast.out b/src/test/isolation/expected/plpgsql-toast.out new file mode 100644 index 0000000..0fee795 --- /dev/null +++ b/src/test/isolation/expected/plpgsql-toast.out @@ -0,0 +1,316 @@ +Parsed test spec with 2 sessions + +starting permutation: lock assign1 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign1: +do $$ + declare + x text; + begin + select test1.b into x from test1; + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(x) = %', length(x); + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(x) = 6000 +step assign1: <... completed> + +starting permutation: lock assign2 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign2: +do $$ + declare + x text; + begin + x := (select test1.b from test1); + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(x) = %', length(x); + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(x) = 6000 +step assign2: <... completed> + +starting permutation: lock assign3 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign3: +do $$ + declare + r record; + begin + select * into r from test1; + r.b := (select test1.b from test1); + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(r) = %', length(r::text); + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(r) = 6004 +step assign3: <... completed> + +starting permutation: lock assign4 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign4: +do $$ + declare + r test2; + begin + select * into r from test1; + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(r) = %', length(r::text); + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(r) = 6004 +step assign4: <... completed> + +starting permutation: lock assign5 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign5: +do $$ + declare + r record; + begin + for r in select test1.b from test1 loop + null; + end loop; + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(r) = %', length(r::text); + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(r) = 6002 +step assign5: <... completed> + +starting permutation: lock assign6 vacuum unlock +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +step lock: + SELECT pg_advisory_lock(1); + +pg_advisory_lock +---------------- + +(1 row) + +step assign6: +do $$ + declare + r record; + begin + insert into test1 values (2, repeat('bar', 3000)); + insert into test1 values (3, repeat('baz', 4000)); + for r in select test1.b from test1 loop + delete from test1; + commit; + perform pg_advisory_lock(1); + raise notice 'length(r) = %', length(r::text); + end loop; + end; +$$; + <waiting ...> +step vacuum: + VACUUM test1; + +step unlock: + SELECT pg_advisory_unlock(1); + +pg_advisory_unlock +------------------ +t +(1 row) + +s1: NOTICE: length(r) = 6002 +s1: NOTICE: length(r) = 9002 +s1: NOTICE: length(r) = 12002 +step assign6: <... completed> + +starting permutation: fetch-after-commit +pg_advisory_unlock_all +---------------------- + +(1 row) + +pg_advisory_unlock_all +---------------------- + +(1 row) + +s1: NOTICE: length(t) = 6000 +s1: NOTICE: length(t) = 9000 +s1: NOTICE: length(t) = 12000 +step fetch-after-commit: +do $$ + declare + r record; + t text; + begin + insert into test1 values (2, repeat('bar', 3000)); + insert into test1 values (3, repeat('baz', 4000)); + for r in select test1.a from test1 loop + commit; + select b into t from test1 where a = r.a; + raise notice 'length(t) = %', length(t); + end loop; + end; +$$; + diff --git a/src/test/isolation/expected/predicate-gin.out b/src/test/isolation/expected/predicate-gin.out new file mode 100644 index 0000000..c032804 --- /dev/null +++ b/src/test/isolation/expected/predicate-gin.out @@ -0,0 +1,581 @@ +Parsed test spec with 3 sessions + +starting permutation: ra1 ro2 wo1 c1 wa2 c2 +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wa2: insert into gin_tbl values (array[1]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 ra1 wo1 c1 wa2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wa2: insert into gin_tbl values (array[1]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 ra1 wo1 wa2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step wo1: insert into other_tbl values (1); +step wa2: insert into gin_tbl values (array[1]); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ra1 ro2 wa2 wo1 c1 c2 +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wa2: insert into gin_tbl values (array[1]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rb1 ro2 wo1 c1 wb2 c2 +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wb2: insert into gin_tbl values (array[2]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rb1 wo1 c1 wb2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wb2: insert into gin_tbl values (array[2]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rb1 wo1 wb2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step wb2: insert into gin_tbl values (array[2]); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rb1 ro2 wb2 wo1 c1 c2 +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wb2: insert into gin_tbl values (array[2]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rc1 ro2 wo1 c1 wc2 c2 +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wc2: insert into gin_tbl values (array[800]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rc1 wo1 c1 wc2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wc2: insert into gin_tbl values (array[800]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rc1 wo1 wc2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step wc2: insert into gin_tbl values (array[800]); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rc1 ro2 wc2 wo1 c1 c2 +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wc2: insert into gin_tbl values (array[800]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ra1 ro2 wo1 c1 wb2 c2 +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wb2: insert into gin_tbl values (array[2]); +step c2: commit; + +starting permutation: ro2 ra1 wo1 c1 wc2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wc2: insert into gin_tbl values (array[800]); +step c2: commit; + +starting permutation: ro2 rb1 wo1 wa2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step wa2: insert into gin_tbl values (array[1]); +step c1: commit; +step c2: commit; + +starting permutation: rc1 ro2 wa2 wo1 c1 c2 +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wa2: insert into gin_tbl values (array[1]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; + +starting permutation: rb1 ro2 wo1 c1 wa2 c2 +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wa2: insert into gin_tbl values (array[1]); +step c2: commit; + +starting permutation: ro2 rb1 wo1 c1 wc2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wc2: insert into gin_tbl values (array[800]); +step c2: commit; + +starting permutation: ro2 ra1 wo1 wb2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step wo1: insert into other_tbl values (1); +step wb2: insert into gin_tbl values (array[2]); +step c1: commit; +step c2: commit; + +starting permutation: rc1 ro2 wb2 wo1 c1 c2 +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wb2: insert into gin_tbl values (array[2]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; + +starting permutation: rc1 ro2 wo1 c1 wa2 c2 +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wa2: insert into gin_tbl values (array[1]); +step c2: commit; + +starting permutation: ro2 rc1 wo1 c1 wb2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rc1: select count(*) from gin_tbl where p @> array[800]; +count +----- + 1 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wb2: insert into gin_tbl values (array[2]); +step c2: commit; + +starting permutation: ro2 ra1 wo1 wc2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step wo1: insert into other_tbl values (1); +step wc2: insert into gin_tbl values (array[800]); +step c1: commit; +step c2: commit; + +starting permutation: rb1 ro2 wc2 wo1 c1 c2 +step rb1: select count(*) from gin_tbl where p @> array[2]; +count +----- + 1 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wc2: insert into gin_tbl values (array[800]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; + +starting permutation: fu ra1 ro2 wo1 c1 wa2 c2 +step fu: alter index ginidx set (fastupdate = on); +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wa2: insert into gin_tbl values (array[1]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: fu ra1 ro2 wo1 c1 wb2 c2 +step fu: alter index ginidx set (fastupdate = on); +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wb2: insert into gin_tbl values (array[2]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ra1 ro2 wo1 c1 fu wa2 c2 +step ra1: select * from gin_tbl where p @> array[1] limit 1; +p +--- +{1} +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step fu: alter index ginidx set (fastupdate = on); +step wa2: insert into gin_tbl values (array[1]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rd1 ro2 wo1 c1 wd2 c2 +step rd1: select count(*) from gin_tbl where p @> array[2000]; +count +----- + 0 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wd2: insert into gin_tbl values (array[2000]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rd1 wo1 c1 wd2 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rd1: select count(*) from gin_tbl where p @> array[2000]; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step c1: commit; +step wd2: insert into gin_tbl values (array[2000]); +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: ro2 rd1 wo1 wd2 c1 c2 +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step rd1: select count(*) from gin_tbl where p @> array[2000]; +count +----- + 0 +(1 row) + +step wo1: insert into other_tbl values (1); +step wd2: insert into gin_tbl values (array[2000]); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rd1 ro2 wd2 wo1 c1 c2 +step rd1: select count(*) from gin_tbl where p @> array[2000]; +count +----- + 0 +(1 row) + +step ro2: select count(*) from other_tbl; +count +----- + 0 +(1 row) + +step wd2: insert into gin_tbl values (array[2000]); +step wo1: insert into other_tbl values (1); +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions diff --git a/src/test/isolation/expected/predicate-gist.out b/src/test/isolation/expected/predicate-gist.out new file mode 100644 index 0000000..ef5d386 --- /dev/null +++ b/src/test/isolation/expected/predicate-gist.out @@ -0,0 +1,819 @@ +Parsed test spec with 2 sessions + +starting permutation: rxy1 wx1 c1 rxy2 wy2 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2233750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; + +starting permutation: rxy2 wy2 c2 rxy1 wx1 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +316250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; + +starting permutation: rxy3 wx3 c1 rxy4 wy4 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; + +starting permutation: rxy4 wy4 c2 rxy3 wx3 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; + +starting permutation: rxy1 wx1 rxy2 c1 wy2 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step c1: commit; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy1 wx1 rxy2 wy2 c1 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wx1 rxy2 wy2 c2 c1 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wx1 c1 wy2 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy1 rxy2 wx1 wy2 c1 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wx1 wy2 c2 c1 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 wx1 c1 c2 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 wx1 c2 c1 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 c2 wx1 c1 +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy2 rxy1 wx1 c1 wy2 c2 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy2 rxy1 wx1 wy2 c1 c2 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wx1 wy2 c2 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 wx1 c1 c2 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 wx1 c2 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 c2 wx1 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step c2: commit; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy2 wy2 rxy1 wx1 c1 c2 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 wy2 rxy1 wx1 c2 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 wy2 rxy1 c2 wx1 c1 +step rxy2: select sum(p[0]) from gist_point_tbl where p >> point(7500,7500); + sum +------- +2188750 +(1 row) + +step wy2: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(1, 5) g; +step rxy1: select sum(p[0]) from gist_point_tbl where p << point(2500, 2500); + sum +------ +311250 +(1 row) + +step c2: commit; +step wx1: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(15, 20) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy3 wx3 rxy4 c1 wy4 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step c1: commit; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; + +starting permutation: rxy3 wx3 rxy4 wy4 c1 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 wx3 rxy4 wy4 c2 c1 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wx3 c1 wy4 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; + +starting permutation: rxy3 rxy4 wx3 wy4 c1 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 rxy4 wx3 wy4 c2 c1 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wy4 wx3 c1 c2 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 rxy4 wy4 wx3 c2 c1 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wy4 c2 wx3 c1 +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; + +starting permutation: rxy4 rxy3 wx3 c1 wy4 c2 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; + +starting permutation: rxy4 rxy3 wx3 wy4 c1 c2 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 rxy3 wx3 wy4 c2 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 rxy3 wy4 wx3 c1 c2 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 rxy3 wy4 wx3 c2 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 rxy3 wy4 c2 wx3 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step c2: commit; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; + +starting permutation: rxy4 wy4 rxy3 wx3 c1 c2 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 wy4 rxy3 wx3 c2 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 wy4 rxy3 c2 wx3 c1 +step rxy4: select sum(p[0]) from gist_point_tbl where p << point(1000,1000); + sum +----- +49500 +(1 row) + +step wy4: insert into gist_point_tbl (id, p) + select g, point(g*50, g*50) from generate_series(1, 20) g; +step rxy3: select sum(p[0]) from gist_point_tbl where p >> point(6000,6000); + sum +------- +3202000 +(1 row) + +step c2: commit; +step wx3: insert into gist_point_tbl (id, p) + select g, point(g*500, g*500) from generate_series(12, 18) g; +step c1: commit; diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out new file mode 100644 index 0000000..2009252 --- /dev/null +++ b/src/test/isolation/expected/predicate-hash.out @@ -0,0 +1,819 @@ +Parsed test spec with 2 sessions + +starting permutation: rxy1 wx1 c1 rxy2 wy2 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +600 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; + +starting permutation: rxy2 wy2 c2 rxy1 wx1 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +400 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; + +starting permutation: rxy3 wx3 c1 rxy4 wy4 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; + +starting permutation: rxy4 wy4 c2 rxy3 wx3 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; + +starting permutation: rxy1 wx1 rxy2 c1 wy2 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step c1: commit; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy1 wx1 rxy2 wy2 c1 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 wx1 rxy2 wy2 c2 c1 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wx1 c1 wy2 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy1 rxy2 wx1 wy2 c1 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wx1 wy2 c2 c1 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 wx1 c1 c2 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 wx1 c2 c1 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy1 rxy2 wy2 c2 wx1 c1 +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy2 rxy1 wx1 c1 wy2 c2 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: commit; + +starting permutation: rxy2 rxy1 wx1 wy2 c1 c2 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wx1 wy2 c2 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 wx1 c1 c2 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 wx1 c2 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 rxy1 wy2 c2 wx1 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step c2: commit; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy2 wy2 rxy1 wx1 c1 c2 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 wy2 rxy1 wx1 c2 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxy2 wy2 rxy1 c2 wx1 c1 +step rxy2: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy2: insert into hash_tbl (id, p) + select g, 20 from generate_series(51, 60) g; +step rxy1: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step c2: commit; +step wx1: insert into hash_tbl (id, p) + select g, 30 from generate_series(41, 50) g; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: commit; + +starting permutation: rxy3 wx3 rxy4 c1 wy4 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step c1: commit; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; + +starting permutation: rxy3 wx3 rxy4 wy4 c1 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 wx3 rxy4 wy4 c2 c1 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wx3 c1 wy4 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; + +starting permutation: rxy3 rxy4 wx3 wy4 c1 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 rxy4 wx3 wy4 c2 c1 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wy4 wx3 c1 c2 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy3 rxy4 wy4 wx3 c2 c1 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy3 rxy4 wy4 c2 wx3 c1 +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; + +starting permutation: rxy4 rxy3 wx3 c1 wy4 c2 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; + +starting permutation: rxy4 rxy3 wx3 wy4 c1 c2 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 rxy3 wx3 wy4 c2 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 rxy3 wy4 wx3 c1 c2 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 rxy3 wy4 wx3 c2 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 rxy3 wy4 c2 wx3 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step c2: commit; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; + +starting permutation: rxy4 wy4 rxy3 wx3 c1 c2 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; +step c2: commit; + +starting permutation: rxy4 wy4 rxy3 wx3 c2 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c2: commit; +step c1: commit; + +starting permutation: rxy4 wy4 rxy3 c2 wx3 c1 +step rxy4: select sum(p) from hash_tbl where p=30; +sum +--- +300 +(1 row) + +step wy4: insert into hash_tbl (id, p) + select g, 60 from generate_series(51, 60) g; +step rxy3: select sum(p) from hash_tbl where p=20; +sum +--- +200 +(1 row) + +step c2: commit; +step wx3: insert into hash_tbl (id, p) + select g, 50 from generate_series(41, 50) g; +step c1: commit; diff --git a/src/test/isolation/expected/predicate-lock-hot-tuple.out b/src/test/isolation/expected/predicate-lock-hot-tuple.out new file mode 100644 index 0000000..d316edb --- /dev/null +++ b/src/test/isolation/expected/predicate-lock-hot-tuple.out @@ -0,0 +1,24 @@ +Parsed test spec with 2 sessions + +starting permutation: b1 b2 r1 r2 w1 w2 c1 c2 +step b1: BEGIN ISOLATION LEVEL SERIALIZABLE; +step b2: BEGIN ISOLATION LEVEL SERIALIZABLE; +step r1: SELECT * FROM test WHERE i IN (5, 7) +i|t +-+---------------- +5|apple +7|pear_hot_updated +(2 rows) + +step r2: SELECT * FROM test WHERE i IN (5, 7) +i|t +-+---------------- +5|apple +7|pear_hot_updated +(2 rows) + +step w1: UPDATE test SET t = 'pear_xact1' WHERE i = 7 +step w2: UPDATE test SET t = 'apple_xact2' WHERE i = 5 +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions diff --git a/src/test/isolation/expected/prepared-transactions-cic.out b/src/test/isolation/expected/prepared-transactions-cic.out new file mode 100644 index 0000000..ac0ee69 --- /dev/null +++ b/src/test/isolation/expected/prepared-transactions-cic.out @@ -0,0 +1,20 @@ +Parsed test spec with 2 sessions + +starting permutation: w1 p1 cic2 c1 r2 +step w1: BEGIN; INSERT INTO cic_test VALUES (1); +step p1: PREPARE TRANSACTION 's1'; +step cic2: + CREATE INDEX CONCURRENTLY on cic_test(a); + +ERROR: canceling statement due to lock timeout +step c1: COMMIT PREPARED 's1'; +step r2: + SET enable_seqscan to off; + SET enable_bitmapscan to off; + SELECT * FROM cic_test WHERE a = 1; + +a +- +1 +(1 row) + diff --git a/src/test/isolation/expected/prepared-transactions.out b/src/test/isolation/expected/prepared-transactions.out new file mode 100644 index 0000000..8a66bf9 --- /dev/null +++ b/src/test/isolation/expected/prepared-transactions.out @@ -0,0 +1,48205 @@ +Parsed test spec with 4 sessions + +starting permutation: r1 r2 w2 w3 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 w3 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 w3 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 p2 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p1 p2 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 w3 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 p1 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 w2 p2 p1 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 w3 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 p2 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 r2 p1 w2 p2 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 r2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p1 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 w3 p3 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w2 p1 w3 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 w2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p1 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 r2 p3 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 r2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p1 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 w2 p3 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 r2 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 w2 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p1 p3 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 r2 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 w2 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 p1 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 r2 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 w2 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 w3 p3 c3 p1 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 w3 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 p2 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 r2 w2 p2 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w2 w3 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 r2 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 w2 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: r1 p1 w3 p3 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 w3 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 w3 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 p2 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p1 p2 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 w3 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 p1 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 r2 p2 p1 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 r2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p1 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 w3 p3 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 w3 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 p2 w3 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 r2 p2 w3 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w2 r1 p1 w3 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 w2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p1 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 r2 p3 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 r2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p1 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 w2 p3 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 r2 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 r2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 w2 p3 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p1 p3 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 r2 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 w2 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 p1 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 r2 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 w2 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r1 p3 c3 p1 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p1 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p1 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p1 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p3 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p3 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p3 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p3 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p2 p3 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 w2 p3 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p2 p3 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p2 p3 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p2: PREPARE TRANSACTION 's2'; +step p3: PREPARE TRANSACTION 's3'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +ERROR: prepared transaction with identifier "s3" does not exist +step c2: COMMIT PREPARED 's2'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p3 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p3 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p3 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p3 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 w2 p3 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p1 p3 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 r1 p3 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 r1 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 r2 p3 c3 r1 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 r2 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 r2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 p1 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 w2 c3 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 r2 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 r2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 r2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 r2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 r2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 r2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 c3 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 c3 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 c3 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 w2 c3 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 p1 c3 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 r2 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 w2 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r1 c3 p1 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p1 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p1 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p1 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p1 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p1 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p2 p1 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p2 p1 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p2 c3 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p2 c3 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 p2 c3 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 w2 c3 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 w2 p2 c3 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 w2 p2 c3 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c3: COMMIT PREPARED 's3'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 w2 c3 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 w2 c3 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 w2 c3 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 c3 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 c3 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 c3 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 p1 c3 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c3: COMMIT PREPARED 's3'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 r1 c3 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 r2 c3 r1 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 r2 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 r2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 p1 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 p1 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 p1 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 w2 p1 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 r2 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 r2 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 r2 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 r2 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 w2 r2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 w2 r2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 w2 r2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 w2 c1 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 c1 r2 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r1 p1 c1 w2 r2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +step r2: SELECT * FROM test3; +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p1 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p1 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p1 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p2 p1 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p2 p1 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step p1: PREPARE TRANSACTION 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 w2 p2 c2 p1 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 p1 w2 p2 c1 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c1: COMMIT PREPARED 's1'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 p1 w2 p2 c2 c1 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step c1: COMMIT PREPARED 's1'; +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 p1 w2 c1 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT PREPARED 's1'; +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + + +starting permutation: w3 p3 c3 r2 r1 p1 c1 w2 p2 c2 check +a +- +(0 rows) + +a +- +(0 rows) + +step w3: INSERT INTO test3 VALUES (3); +step p3: PREPARE TRANSACTION 's3'; +step c3: COMMIT PREPARED 's3'; +step r2: SELECT * FROM test3; +c +- +(0 rows) + +step r1: SELECT * FROM test2; +b +- +(0 rows) + +step p1: PREPARE TRANSACTION 's1'; +step c1: COMMIT PREPARED 's1'; +step w2: INSERT INTO test2 VALUES (2); +ERROR: could not serialize access due to read/write dependencies among transactions +step p2: PREPARE TRANSACTION 's2'; +step c2: COMMIT PREPARED 's2'; +ERROR: prepared transaction with identifier "s2" does not exist +step check: SELECT * FROM test1,test2,test3; +a|b|c +-+-+- +(0 rows) + diff --git a/src/test/isolation/expected/project-manager.out b/src/test/isolation/expected/project-manager.out new file mode 100644 index 0000000..902d188 --- /dev/null +++ b/src/test/isolation/expected/project-manager.out @@ -0,0 +1,379 @@ +Parsed test spec with 2 sessions + +starting permutation: rx1 wy1 c1 ry2 wx2 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 1 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 c1 wx2 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step c1: COMMIT; +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 wx2 c1 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 wy1 ry2 wx2 c2 c1 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 c1 wx2 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 ry2 wy1 wx2 c1 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 wx2 c2 c1 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c1 c2 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c2 c1 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 c2 wy1 c1 +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 rx1 wy1 c1 wx2 c2 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: ry2 rx1 wy1 wx2 c1 c2 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wy1 wx2 c2 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c1 c2 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c2 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 c2 wy1 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 rx1 wy1 c1 c2 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 wy1 c2 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 c2 wy1 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 1 +(1 row) + +step c2: COMMIT; +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 c2 rx1 wy1 c1 +step ry2: SELECT count(*) FROM project WHERE project_manager = 1; +count +----- + 0 +(1 row) + +step wx2: UPDATE person SET is_project_manager = false WHERE person_id = 1; +step c2: COMMIT; +step rx1: SELECT count(*) FROM person WHERE person_id = 1 AND is_project_manager; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO project VALUES (101, 'Build Great Wall', 1); +step c1: COMMIT; diff --git a/src/test/isolation/expected/propagate-lock-delete.out b/src/test/isolation/expected/propagate-lock-delete.out new file mode 100644 index 0000000..222b945 --- /dev/null +++ b/src/test/isolation/expected/propagate-lock-delete.out @@ -0,0 +1,105 @@ +Parsed test spec with 3 sessions + +starting permutation: s1b s1l s2b s2l s3b s3u s3d s1c s2c s3c +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s2b: BEGIN; +step s2l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u: UPDATE parent SET c=lower(c); +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s2c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s2b: BEGIN; +step s2l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u: UPDATE parent SET c=lower(c); +step s3svu: SAVEPOINT f; UPDATE parent SET c = 'bbb'; ROLLBACK TO f; +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s2c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s2b: BEGIN; +step s2l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u2: UPDATE parent SET i = i; +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s2c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s2b: BEGIN; +step s2l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u2: UPDATE parent SET i = i; +step s3svu: SAVEPOINT f; UPDATE parent SET c = 'bbb'; ROLLBACK TO f; +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s2c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u: UPDATE parent SET c=lower(c); +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u: UPDATE parent SET c=lower(c); +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: 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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u2: UPDATE parent SET i = i; +step s3d: DELETE FROM parent; <waiting ...> +step s1c: COMMIT; +step s3d: <... completed> +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 +step s1b: BEGIN; +step s1l: INSERT INTO child VALUES (1); +step s3b: BEGIN; +step s3u2: UPDATE parent SET i = i; +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: update or delete on table "parent" violates foreign key constraint "child_i_fkey" on table "child" +step s3c: COMMIT; diff --git a/src/test/isolation/expected/read-only-anomaly-2.out b/src/test/isolation/expected/read-only-anomaly-2.out new file mode 100644 index 0000000..543ae89 --- /dev/null +++ b/src/test/isolation/expected/read-only-anomaly-2.out @@ -0,0 +1,58 @@ +Parsed test spec with 3 sessions + +starting permutation: s2rx s2ry s1ry s1wy s1c s2wx s2c s3c +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +step s2c: COMMIT; +step s3c: COMMIT; + +starting permutation: s2rx s2ry s1ry s1wy s1c s3r s3c s2wx +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s3r: SELECT id, balance FROM bank_account WHERE id IN ('X', 'Y') ORDER BY id; +id|balance +--+------- +X | 0 +Y | 20 +(2 rows) + +step s3c: COMMIT; +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +ERROR: could not serialize access due to read/write dependencies among transactions diff --git a/src/test/isolation/expected/read-only-anomaly-3.out b/src/test/isolation/expected/read-only-anomaly-3.out new file mode 100644 index 0000000..4f7d3f8 --- /dev/null +++ b/src/test/isolation/expected/read-only-anomaly-3.out @@ -0,0 +1,34 @@ +Parsed test spec with 3 sessions + +starting permutation: s2rx s2ry s1ry s1wy s1c s3r s2wx s2c s3c +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s3r: SELECT id, balance FROM bank_account WHERE id IN ('X', 'Y') ORDER BY id; <waiting ...> +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +step s2c: COMMIT; +step s3r: <... completed> +id|balance +--+------- +X | -11 +Y | 20 +(2 rows) + +step s3c: COMMIT; diff --git a/src/test/isolation/expected/read-only-anomaly.out b/src/test/isolation/expected/read-only-anomaly.out new file mode 100644 index 0000000..96df5e2 --- /dev/null +++ b/src/test/isolation/expected/read-only-anomaly.out @@ -0,0 +1,33 @@ +Parsed test spec with 3 sessions + +starting permutation: s2rx s2ry s1ry s1wy s1c s3r s2wx s2c s3c +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s3r: SELECT id, balance FROM bank_account WHERE id IN ('X', 'Y') ORDER BY id; +id|balance +--+------- +X | 0 +Y | 20 +(2 rows) + +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +step s2c: COMMIT; +step s3c: COMMIT; diff --git a/src/test/isolation/expected/read-write-unique-2.out b/src/test/isolation/expected/read-write-unique-2.out new file mode 100644 index 0000000..13b7cdc --- /dev/null +++ b/src/test/isolation/expected/read-write-unique-2.out @@ -0,0 +1,37 @@ +Parsed test spec with 2 sessions + +starting permutation: r1 r2 w1 w2 c1 c2 +step r1: SELECT * FROM test WHERE i = 42; +i +- +(0 rows) + +step r2: SELECT * FROM test WHERE i = 42; +i +- +(0 rows) + +step w1: INSERT INTO test VALUES (42); +step w2: INSERT INTO test VALUES (42); <waiting ...> +step c1: COMMIT; +step w2: <... completed> +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: r1 w1 c1 r2 w2 c2 +step r1: SELECT * FROM test WHERE i = 42; +i +- +(0 rows) + +step w1: INSERT INTO test VALUES (42); +step c1: COMMIT; +step r2: SELECT * FROM test WHERE i = 42; + i +-- +42 +(1 row) + +step w2: INSERT INTO test VALUES (42); +ERROR: duplicate key value violates unique constraint "test_pkey" +step c2: COMMIT; diff --git a/src/test/isolation/expected/read-write-unique-3.out b/src/test/isolation/expected/read-write-unique-3.out new file mode 100644 index 0000000..7735d5e --- /dev/null +++ b/src/test/isolation/expected/read-write-unique-3.out @@ -0,0 +1,14 @@ +Parsed test spec with 2 sessions + +starting permutation: rw1 rw2 c1 c2 +step rw1: SELECT insert_unique(1, '1'); +insert_unique +------------- + +(1 row) + +step rw2: SELECT insert_unique(1, '2'); <waiting ...> +step c1: COMMIT; +step rw2: <... completed> +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; diff --git a/src/test/isolation/expected/read-write-unique-4.out b/src/test/isolation/expected/read-write-unique-4.out new file mode 100644 index 0000000..aa96530 --- /dev/null +++ b/src/test/isolation/expected/read-write-unique-4.out @@ -0,0 +1,49 @@ +Parsed test spec with 2 sessions + +starting permutation: r1 r2 w1 w2 c1 c2 +step r1: SELECT COALESCE(MAX(invoice_number) + 1, 1) FROM invoice WHERE year = 2016; +coalesce +-------- + 3 +(1 row) + +step r2: SELECT COALESCE(MAX(invoice_number) + 1, 1) FROM invoice WHERE year = 2016; +coalesce +-------- + 3 +(1 row) + +step w1: INSERT INTO invoice VALUES (2016, 3); +step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...> +step c1: COMMIT; +step w2: <... completed> +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: r1 w1 w2 c1 c2 +step r1: SELECT COALESCE(MAX(invoice_number) + 1, 1) FROM invoice WHERE year = 2016; +coalesce +-------- + 3 +(1 row) + +step w1: INSERT INTO invoice VALUES (2016, 3); +step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...> +step c1: COMMIT; +step w2: <... completed> +ERROR: duplicate key value violates unique constraint "invoice_pkey" +step c2: COMMIT; + +starting permutation: r2 w1 w2 c1 c2 +step r2: SELECT COALESCE(MAX(invoice_number) + 1, 1) FROM invoice WHERE year = 2016; +coalesce +-------- + 3 +(1 row) + +step w1: INSERT INTO invoice VALUES (2016, 3); +step w2: INSERT INTO invoice VALUES (2016, 3); <waiting ...> +step c1: COMMIT; +step w2: <... completed> +ERROR: duplicate key value violates unique constraint "invoice_pkey" +step c2: COMMIT; diff --git a/src/test/isolation/expected/read-write-unique.out b/src/test/isolation/expected/read-write-unique.out new file mode 100644 index 0000000..2abecc6 --- /dev/null +++ b/src/test/isolation/expected/read-write-unique.out @@ -0,0 +1,37 @@ +Parsed test spec with 2 sessions + +starting permutation: r1 r2 w1 w2 c1 c2 +step r1: SELECT * FROM test; +i +- +(0 rows) + +step r2: SELECT * FROM test; +i +- +(0 rows) + +step w1: INSERT INTO test VALUES (42); +step w2: INSERT INTO test VALUES (42); <waiting ...> +step c1: COMMIT; +step w2: <... completed> +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: r1 w1 c1 r2 w2 c2 +step r1: SELECT * FROM test; +i +- +(0 rows) + +step w1: INSERT INTO test VALUES (42); +step c1: COMMIT; +step r2: SELECT * FROM test; + i +-- +42 +(1 row) + +step w2: INSERT INTO test VALUES (42); +ERROR: duplicate key value violates unique constraint "test_pkey" +step c2: COMMIT; diff --git a/src/test/isolation/expected/receipt-report.out b/src/test/isolation/expected/receipt-report.out new file mode 100644 index 0000000..1f25018 --- /dev/null +++ b/src/test/isolation/expected/receipt-report.out @@ -0,0 +1,4215 @@ +Parsed test spec with 3 sessions + +starting permutation: rxwy1 c1 wx2 c2 rx3 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 c1 wx2 rx3 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 c1 wx2 rx3 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 c1 wx2 rx3 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 c1 rx3 wx2 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 c1 rx3 wx2 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 c1 rx3 wx2 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 c1 rx3 ry3 wx2 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 c1 rx3 ry3 wx2 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 c1 rx3 ry3 c3 wx2 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rxwy1 wx2 c1 c2 rx3 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c1 rx3 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c1 rx3 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c1 rx3 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 wx2 c2 c1 rx3 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c2 rx3 c1 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c2 rx3 ry3 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: rxwy1 wx2 c2 rx3 ry3 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxwy1 wx2 rx3 c1 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 c1 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 c1 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 wx2 rx3 c2 c1 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 c2 ry3 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 c2 ry3 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c1 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c1 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c2 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c2 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c3 c1 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 wx2 rx3 ry3 c3 c2 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 c1 wx2 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 rx3 c1 wx2 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 c1 wx2 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 c1 ry3 wx2 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 c1 ry3 wx2 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 c1 ry3 c3 wx2 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c1 c2 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c1 ry3 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c1 ry3 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c2 c1 ry3 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c2 ry3 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 c2 ry3 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c1 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c1 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c2 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c2 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c3 c1 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 wx2 ry3 c3 c2 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c1 wx2 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c1 wx2 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c1 c3 wx2 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c1 c2 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c1 c3 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c2 c1 c3 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c2 c3 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c3 c1 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 wx2 c3 c2 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c3 c1 wx2 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c3 wx2 c1 c2 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy1 rx3 ry3 c3 wx2 c2 c1 +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rxwy1 c1 c2 rx3 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c1 rx3 c2 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c1 rx3 ry3 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c1 rx3 ry3 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rxwy1 c2 c1 rx3 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 + 3| 12-22-2008| 4.00 +(3 rows) + +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c2 rx3 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c2 rx3 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: wx2 rxwy1 c2 rx3 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx2 rxwy1 rx3 c1 c2 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 c1 ry3 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 c1 ry3 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rxwy1 rx3 c2 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 c2 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 c2 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c1 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c1 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c2 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c2 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c3 c1 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rxwy1 rx3 ry3 c3 c2 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 c2 rxwy1 c1 rx3 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 c2 rxwy1 rx3 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 c2 rxwy1 rx3 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 c2 rxwy1 rx3 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 c2 rx3 rxwy1 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 c2 rx3 rxwy1 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 c2 rx3 rxwy1 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 c2 rx3 ry3 rxwy1 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 c2 rx3 ry3 rxwy1 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 c2 rx3 ry3 c3 rxwy1 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-23-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c1 c2 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c1 ry3 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c1 ry3 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c2 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c2 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 c2 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c1 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c1 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c2 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c2 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c3 c1 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 rxwy1 ry3 c3 c2 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 c2 rxwy1 c1 ry3 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: wx2 rx3 c2 rxwy1 ry3 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 c2 rxwy1 ry3 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 c2 ry3 rxwy1 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 c2 ry3 rxwy1 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 c2 ry3 c3 rxwy1 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c1 c2 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c1 c3 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c2 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c2 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c3 c1 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 ry3 rxwy1 c3 c2 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 c2 rxwy1 c1 c3 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx2 rx3 ry3 c2 rxwy1 c3 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 c2 c3 rxwy1 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 c3 rxwy1 c1 c2 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx2 rx3 ry3 c3 rxwy1 c2 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx2 rx3 ry3 c3 c2 rxwy1 c1 +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 rxwy1 c1 wx2 c2 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 rxwy1 c1 wx2 ry3 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 c1 wx2 ry3 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 c1 ry3 wx2 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 c1 ry3 wx2 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 c1 ry3 c3 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c1 c2 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c1 ry3 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c1 ry3 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c2 c1 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c2 ry3 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 c2 ry3 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 wx2 ry3 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c1 wx2 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c1 wx2 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c1 c3 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 wx2 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c3 c1 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c3 wx2 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 rxwy1 ry3 c3 wx2 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c1 c2 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c1 ry3 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c1 ry3 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c2 c1 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c2 ry3 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 c2 ry3 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 rxwy1 ry3 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 c2 rxwy1 c1 ry3 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; + +starting permutation: rx3 wx2 c2 rxwy1 ry3 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 c2 rxwy1 ry3 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 c2 ry3 rxwy1 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 c2 ry3 rxwy1 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 c2 ry3 c3 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 ry3 rxwy1 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 c2 rxwy1 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 wx2 ry3 c2 rxwy1 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 c2 c3 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c2: COMMIT; +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 c3 rxwy1 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 wx2 ry3 c3 rxwy1 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 wx2 ry3 c3 c2 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c1 wx2 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c1 wx2 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c1 c3 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 wx2 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c3 c1 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c3 wx2 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 rxwy1 c3 wx2 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c1 c2 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c1 c3 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c2 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c2 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c3 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 wx2 rxwy1 c3 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 c2 rxwy1 c1 c3 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rx3 ry3 wx2 c2 rxwy1 c3 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 c2 c3 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 c3 rxwy1 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 wx2 c3 rxwy1 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 wx2 c3 c2 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c3: COMMIT; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; + +starting permutation: rx3 ry3 c3 rxwy1 c1 wx2 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; + +starting permutation: rx3 ry3 c3 rxwy1 wx2 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 c3 rxwy1 wx2 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 c3 wx2 rxwy1 c1 c2 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rx3 ry3 c3 wx2 rxwy1 c2 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rx3 ry3 c3 wx2 c2 rxwy1 c1 +step rx3: SELECT * FROM ctl WHERE k = 'receipt'; +k |deposit_date +-------+------------ +receipt| 12-22-2008 +(1 row) + +step ry3: SELECT * FROM receipt WHERE deposit_date = DATE '2008-12-22'; +receipt_no|deposit_date|amount +----------+------------+------ + 1| 12-22-2008| 1.00 + 2| 12-22-2008| 2.00 +(2 rows) + +step c3: COMMIT; +step wx2: UPDATE ctl SET deposit_date = DATE '2008-12-23' WHERE k = 'receipt'; +step c2: COMMIT; +step rxwy1: INSERT INTO receipt VALUES (3, (SELECT deposit_date FROM ctl WHERE k = 'receipt'), 4.00); +step c1: COMMIT; diff --git a/src/test/isolation/expected/referential-integrity.out b/src/test/isolation/expected/referential-integrity.out new file mode 100644 index 0000000..7679397 --- /dev/null +++ b/src/test/isolation/expected/referential-integrity.out @@ -0,0 +1,839 @@ +Parsed test spec with 2 sessions + +starting permutation: rx1 wy1 c1 rx2 ry2 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- + 1 +(1 row) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; + +starting permutation: rx1 wy1 rx2 c1 ry2 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step c1: COMMIT; +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 wy1 rx2 ry2 c1 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 wy1 rx2 ry2 wx2 c1 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 wy1 rx2 ry2 wx2 c2 c1 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 wy1 c1 ry2 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 rx2 wy1 ry2 c1 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 rx2 wy1 ry2 wx2 c1 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 wy1 ry2 wx2 c2 c1 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 ry2 wy1 c1 wx2 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 rx2 ry2 wy1 wx2 c1 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 ry2 wy1 wx2 c2 c1 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 ry2 wx2 wy1 c1 c2 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 ry2 wx2 wy1 c2 c1 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 rx2 ry2 wx2 c2 wy1 c1 +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step wy1: INSERT INTO b VALUES (1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: rx2 rx1 wy1 c1 ry2 wx2 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx2 rx1 wy1 ry2 c1 wx2 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx2 rx1 wy1 ry2 wx2 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 wy1 ry2 wx2 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 ry2 wy1 c1 wx2 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx2 rx1 ry2 wy1 wx2 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 ry2 wy1 wx2 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 ry2 wx2 wy1 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 ry2 wx2 wy1 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 rx1 ry2 wx2 c2 wy1 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step wy1: INSERT INTO b VALUES (1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: rx2 ry2 rx1 wy1 c1 wx2 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step wx2: DELETE FROM a WHERE i = 1; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx2 ry2 rx1 wy1 wx2 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 rx1 wy1 wx2 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 rx1 wx2 wy1 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 rx1 wx2 wy1 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wx2: DELETE FROM a WHERE i = 1; +step wy1: INSERT INTO b VALUES (1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 rx1 wx2 c2 wy1 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step wy1: INSERT INTO b VALUES (1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: rx2 ry2 wx2 rx1 wy1 c1 c2 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 wx2 rx1 wy1 c2 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step wy1: INSERT INTO b VALUES (1); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx2 ry2 wx2 rx1 c2 wy1 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step rx1: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step c2: COMMIT; +step wy1: INSERT INTO b VALUES (1); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: rx2 ry2 wx2 c2 rx1 wy1 c1 +step rx2: SELECT i FROM a WHERE i = 1; +i +- +1 +(1 row) + +step ry2: SELECT a_id FROM b WHERE a_id = 1; +a_id +---- +(0 rows) + +step wx2: DELETE FROM a WHERE i = 1; +step c2: COMMIT; +step rx1: SELECT i FROM a WHERE i = 1; +i +- +(0 rows) + +step wy1: INSERT INTO b VALUES (1); +step c1: COMMIT; diff --git a/src/test/isolation/expected/reindex-concurrently.out b/src/test/isolation/expected/reindex-concurrently.out new file mode 100644 index 0000000..eea5b2b --- /dev/null +++ b/src/test/isolation/expected/reindex-concurrently.out @@ -0,0 +1,90 @@ +Parsed test spec with 3 sessions + +starting permutation: reindex sel1 upd2 ins2 del2 end1 end2 +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step end1: COMMIT; +step end2: COMMIT; + +starting permutation: sel1 reindex upd2 ins2 del2 end1 end2 +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; <waiting ...> +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step end1: COMMIT; +step end2: COMMIT; +step reindex: <... completed> + +starting permutation: sel1 upd2 reindex ins2 del2 end1 end2 +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; <waiting ...> +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step end1: COMMIT; +step end2: COMMIT; +step reindex: <... completed> + +starting permutation: sel1 upd2 ins2 reindex del2 end1 end2 +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; <waiting ...> +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step end1: COMMIT; +step end2: COMMIT; +step reindex: <... completed> + +starting permutation: sel1 upd2 ins2 del2 reindex end1 end2 +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; <waiting ...> +step end1: COMMIT; +step end2: COMMIT; +step reindex: <... completed> + +starting permutation: sel1 upd2 ins2 del2 end1 reindex end2 +step sel1: SELECT data FROM reind_con_tab WHERE id = 3; +data +---- +aaaa +(1 row) + +step upd2: UPDATE reind_con_tab SET data = 'bbbb' WHERE id = 3; +step ins2: INSERT INTO reind_con_tab(data) VALUES ('cccc'); +step del2: DELETE FROM reind_con_tab WHERE data = 'cccc'; +step end1: COMMIT; +step reindex: REINDEX TABLE CONCURRENTLY reind_con_tab; <waiting ...> +step end2: COMMIT; +step reindex: <... completed> diff --git a/src/test/isolation/expected/ri-trigger.out b/src/test/isolation/expected/ri-trigger.out new file mode 100644 index 0000000..842df80 --- /dev/null +++ b/src/test/isolation/expected/ri-trigger.out @@ -0,0 +1,131 @@ +Parsed test spec with 2 sessions + +starting permutation: wxry1 c1 r2 wyrx2 c2 +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step c1: COMMIT; +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +ERROR: child row exists +step c2: COMMIT; + +starting permutation: wxry1 r2 c1 wyrx2 c2 +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step c1: COMMIT; +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: wxry1 r2 wyrx2 c1 c2 +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wxry1 r2 wyrx2 c2 c1 +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: r2 wxry1 c1 wyrx2 c2 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step c1: COMMIT; +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: r2 wxry1 wyrx2 c1 c2 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: r2 wxry1 wyrx2 c2 c1 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: r2 wyrx2 wxry1 c1 c2 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: r2 wyrx2 wxry1 c2 c1 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step wxry1: INSERT INTO child (parent_id) VALUES (0); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: r2 wyrx2 c2 wxry1 c1 +step r2: SELECT TRUE; +bool +---- +t +(1 row) + +step wyrx2: DELETE FROM parent WHERE parent_id = 0; +step c2: COMMIT; +step wxry1: INSERT INTO child (parent_id) VALUES (0); +ERROR: parent row missing +step c1: COMMIT; diff --git a/src/test/isolation/expected/sequence-ddl.out b/src/test/isolation/expected/sequence-ddl.out new file mode 100644 index 0000000..52b0538 --- /dev/null +++ b/src/test/isolation/expected/sequence-ddl.out @@ -0,0 +1,91 @@ +Parsed test spec with 2 sessions + +starting permutation: s1alter s1commit s2nv +step s1alter: ALTER SEQUENCE seq1 MAXVALUE 10; +step s1commit: COMMIT; +step s2nv: SELECT nextval('seq1') FROM generate_series(1, 15); +ERROR: nextval: reached maximum value of sequence "seq1" (10) + +starting permutation: s1alter s2nv s1commit +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: nextval: reached maximum value of sequence "seq1" (10) + +starting permutation: s1restart s2nv s1commit +step s1restart: ALTER SEQUENCE seq1 RESTART WITH 5; +step s2nv: SELECT nextval('seq1') FROM generate_series(1, 15); <waiting ...> +step s1commit: COMMIT; +step s2nv: <... completed> +nextval +------- + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 +(15 rows) + + +starting permutation: s1restart s2nv s1commit +step s1restart: ALTER SEQUENCE seq1 RESTART WITH 5; +step s2nv: SELECT nextval('seq1') FROM generate_series(1, 15); <waiting ...> +step s1commit: COMMIT; +step s2nv: <... completed> +nextval +------- + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 +(15 rows) + + +starting permutation: s2begin s2nv s1alter2 s2commit s1commit +step s2begin: BEGIN; +step s2nv: SELECT nextval('seq1') FROM generate_series(1, 15); +nextval +------- + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 +(15 rows) + +step s1alter2: ALTER SEQUENCE seq1 MAXVALUE 20; <waiting ...> +step s2commit: COMMIT; +step s1alter2: <... completed> +step s1commit: COMMIT; diff --git a/src/test/isolation/expected/serializable-parallel-2.out b/src/test/isolation/expected/serializable-parallel-2.out new file mode 100644 index 0000000..92753cc --- /dev/null +++ b/src/test/isolation/expected/serializable-parallel-2.out @@ -0,0 +1,50 @@ +Parsed test spec with 2 sessions + +starting permutation: s1r s2r1 s1c s2r2 s2c +step s1r: SELECT * FROM foo; + a +-- + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +(10 rows) + +step s2r1: SELECT * FROM foo; + a +-- + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +(10 rows) + +step s1c: COMMIT; +step s2r2: SELECT * FROM foo; + a +-- + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +10 +(10 rows) + +step s2c: COMMIT; diff --git a/src/test/isolation/expected/serializable-parallel.out b/src/test/isolation/expected/serializable-parallel.out new file mode 100644 index 0000000..543ae89 --- /dev/null +++ b/src/test/isolation/expected/serializable-parallel.out @@ -0,0 +1,58 @@ +Parsed test spec with 3 sessions + +starting permutation: s2rx s2ry s1ry s1wy s1c s2wx s2c s3c +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +step s2c: COMMIT; +step s3c: COMMIT; + +starting permutation: s2rx s2ry s1ry s1wy s1c s3r s3c s2wx +step s2rx: SELECT balance FROM bank_account WHERE id = 'X'; +balance +------- + 0 +(1 row) + +step s2ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1ry: SELECT balance FROM bank_account WHERE id = 'Y'; +balance +------- + 0 +(1 row) + +step s1wy: UPDATE bank_account SET balance = 20 WHERE id = 'Y'; +step s1c: COMMIT; +step s3r: SELECT id, balance FROM bank_account WHERE id IN ('X', 'Y') ORDER BY id; +id|balance +--+------- +X | 0 +Y | 20 +(2 rows) + +step s3c: COMMIT; +step s2wx: UPDATE bank_account SET balance = -11 WHERE id = 'X'; +ERROR: could not serialize access due to read/write dependencies among transactions diff --git a/src/test/isolation/expected/simple-write-skew.out b/src/test/isolation/expected/simple-write-skew.out new file mode 100644 index 0000000..835500d --- /dev/null +++ b/src/test/isolation/expected/simple-write-skew.out @@ -0,0 +1,41 @@ +Parsed test spec with 2 sessions + +starting permutation: rwx1 c1 rwx2 c2 +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step c1: COMMIT; +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step c2: COMMIT; + +starting permutation: rwx1 rwx2 c1 c2 +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rwx1 rwx2 c2 c1 +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rwx2 rwx1 c1 c2 +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rwx2 rwx1 c2 c1 +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rwx2 c2 rwx1 c1 +step rwx2: UPDATE test SET t = 'pear' WHERE t = 'apple' +step c2: COMMIT; +step rwx1: UPDATE test SET t = 'apple' WHERE t = 'pear'; +step c1: COMMIT; diff --git a/src/test/isolation/expected/skip-locked-2.out b/src/test/isolation/expected/skip-locked-2.out new file mode 100644 index 0000000..3302d2e --- /dev/null +++ b/src/test/isolation/expected/skip-locked-2.out @@ -0,0 +1,67 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s2a s2b s1b s2c +step s1a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c +step s2a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c +step s2a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR SHARE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: COMMIT; +step s2c: COMMIT; diff --git a/src/test/isolation/expected/skip-locked-3.out b/src/test/isolation/expected/skip-locked-3.out new file mode 100644 index 0000000..be1f84d --- /dev/null +++ b/src/test/isolation/expected/skip-locked-3.out @@ -0,0 +1,25 @@ +Parsed test spec with 3 sessions + +starting permutation: s1a s2a s3a s1b s2b s3b +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE LIMIT 1; <waiting ...> +step s3a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: COMMIT; +step s2a: <... completed> +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: COMMIT; +step s3b: COMMIT; diff --git a/src/test/isolation/expected/skip-locked-4.out b/src/test/isolation/expected/skip-locked-4.out new file mode 100644 index 0000000..cfa9ae1 --- /dev/null +++ b/src/test/isolation/expected/skip-locked-4.out @@ -0,0 +1,27 @@ +Parsed test spec with 2 sessions + +starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f +step s2a: SELECT pg_advisory_lock(0); +pg_advisory_lock +---------------- + +(1 row) + +step s1a: SELECT * FROM foo WHERE pg_advisory_lock(0) IS NOT NULL ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; <waiting ...> +step s2b: UPDATE foo SET data = data WHERE id = 1; +step s2c: BEGIN; +step s2d: UPDATE foo SET data = data WHERE id = 1; +step s2e: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1a: <... completed> +id|data +--+---- + 2|x +(1 row) + +step s1b: COMMIT; +step s2f: COMMIT; diff --git a/src/test/isolation/expected/skip-locked-4_1.out b/src/test/isolation/expected/skip-locked-4_1.out new file mode 100644 index 0000000..489dcab --- /dev/null +++ b/src/test/isolation/expected/skip-locked-4_1.out @@ -0,0 +1,23 @@ +Parsed test spec with 2 sessions + +starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f +step s2a: SELECT pg_advisory_lock(0); +pg_advisory_lock +---------------- + +(1 row) + +step s1a: SELECT * FROM foo WHERE pg_advisory_lock(0) IS NOT NULL ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; <waiting ...> +step s2b: UPDATE foo SET data = data WHERE id = 1; +step s2c: BEGIN; +step s2d: UPDATE foo SET data = data WHERE id = 1; +step s2e: SELECT pg_advisory_unlock(0); +pg_advisory_unlock +------------------ +t +(1 row) + +step s1a: <... completed> +ERROR: could not serialize access due to concurrent update +step s1b: COMMIT; +step s2f: COMMIT; diff --git a/src/test/isolation/expected/skip-locked.out b/src/test/isolation/expected/skip-locked.out new file mode 100644 index 0000000..3dc5768 --- /dev/null +++ b/src/test/isolation/expected/skip-locked.out @@ -0,0 +1,561 @@ +Parsed test spec with 2 sessions + +starting permutation: s1a s1b s1c s2a s2b s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; + +starting permutation: s1a s1b s2a s1c s2b s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; + +starting permutation: s1a s1b s2a s2b s1c s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1a s1b s2a s2b s2c s1c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1a s2a s1b s1c s2b s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; + +starting permutation: s1a s2a s1b s2b s1c s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1a s2a s1b s2b s2c s1c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1a s2a s2b s1b s1c s2c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s1a s2a s2b s1b s2c s1c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1a s2a s2b s2c s1b s1c +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; + +starting permutation: s2a s1a s1b s1c s2b s2c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; + +starting permutation: s2a s1a s1b s2b s1c s2c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s1a s1b s2b s2c s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s2a s1a s2b s1b s1c s2c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s1a s2b s1b s2c s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s2a s1a s2b s2c s1b s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s1b s1c s2c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1c: COMMIT; +step s2c: COMMIT; + +starting permutation: s2a s2b s1a s1b s2c s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s2a s2b s1a s2c s1b s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 2|bar |NEW +(1 row) + +step s2c: COMMIT; +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; + +starting permutation: s2a s2b s2c s1a s1b s1c +step s2a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s2c: COMMIT; +step s1a: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1b: SELECT * FROM queue ORDER BY id FOR UPDATE SKIP LOCKED LIMIT 1; +id|data|status +--+----+------ + 1|foo |NEW +(1 row) + +step s1c: COMMIT; diff --git a/src/test/isolation/expected/temporal-range-integrity.out b/src/test/isolation/expected/temporal-range-integrity.out new file mode 100644 index 0000000..039193e --- /dev/null +++ b/src/test/isolation/expected/temporal-range-integrity.out @@ -0,0 +1,379 @@ +Parsed test spec with 2 sessions + +starting permutation: rx1 wy1 c1 ry2 wx2 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 1 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 c1 wx2 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step c1: COMMIT; +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 wy1 ry2 wx2 c1 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 wy1 ry2 wx2 c2 c1 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 c1 wx2 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: rx1 ry2 wy1 wx2 c1 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wy1 wx2 c2 c1 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c1 c2 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 wy1 c2 c1 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rx1 ry2 wx2 c2 wy1 c1 +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 rx1 wy1 c1 wx2 c2 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: ry2 rx1 wy1 wx2 c1 c2 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wy1 wx2 c2 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c1 c2 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 wy1 c2 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 rx1 wx2 c2 wy1 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 rx1 wy1 c1 c2 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 wy1 c2 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry2 wx2 rx1 c2 wy1 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 1 +(1 row) + +step c2: COMMIT; +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: ry2 wx2 c2 rx1 wy1 c1 +step ry2: SELECT count(*) FROM offense WHERE statute_cite = '123.45(1)a' AND offense_date >= DATE '2008-01-01'; +count +----- + 0 +(1 row) + +step wx2: DELETE FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date = DATE '2008-01-01'; +step c2: COMMIT; +step rx1: SELECT count(*) FROM statute WHERE statute_cite = '123.45(1)a' AND eff_date <= DATE '2009-05-15' AND (exp_date IS NULL OR exp_date > DATE '2009-05-15'); +count +----- + 0 +(1 row) + +step wy1: INSERT INTO offense VALUES (1, '123.45(1)a', DATE '2009-05-15'); +step c1: COMMIT; diff --git a/src/test/isolation/expected/timeouts.out b/src/test/isolation/expected/timeouts.out new file mode 100644 index 0000000..9328676 --- /dev/null +++ b/src/test/isolation/expected/timeouts.out @@ -0,0 +1,81 @@ +Parsed test spec with 2 sessions + +starting permutation: rdtbl sto locktbl +step rdtbl: SELECT * FROM accounts; +accountid|balance +---------+------- +checking | 600 +savings | 600 +(2 rows) + +step sto: SET statement_timeout = '10ms'; +step locktbl: LOCK TABLE accounts; <waiting ...> +step locktbl: <... completed> +ERROR: canceling statement due to statement timeout + +starting permutation: rdtbl lto locktbl +step rdtbl: SELECT * FROM accounts; +accountid|balance +---------+------- +checking | 600 +savings | 600 +(2 rows) + +step lto: SET lock_timeout = '10ms'; +step locktbl: LOCK TABLE accounts; <waiting ...> +step locktbl: <... completed> +ERROR: canceling statement due to lock timeout + +starting permutation: rdtbl lsto locktbl +step rdtbl: SELECT * FROM accounts; +accountid|balance +---------+------- +checking | 600 +savings | 600 +(2 rows) + +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 + +starting permutation: rdtbl slto locktbl +step rdtbl: SELECT * FROM accounts; +accountid|balance +---------+------- +checking | 600 +savings | 600 +(2 rows) + +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 = '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 = '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 = '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 = '10s'; SET statement_timeout = '10ms'; +step update: DELETE FROM accounts WHERE accountid = 'checking'; <waiting ...> +step update: <... completed> +ERROR: canceling statement due to statement timeout diff --git a/src/test/isolation/expected/total-cash.out b/src/test/isolation/expected/total-cash.out new file mode 100644 index 0000000..7b00e0d --- /dev/null +++ b/src/test/isolation/expected/total-cash.out @@ -0,0 +1,349 @@ +Parsed test spec with 2 sessions + +starting permutation: wx1 rxy1 c1 wy2 rxy2 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; +sum +--- +800 +(1 row) + +step c2: COMMIT; + +starting permutation: wx1 rxy1 wy2 c1 rxy2 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step c1: COMMIT; +step rxy2: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: wx1 rxy1 wy2 rxy2 c1 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 rxy1 wy2 rxy2 c2 c1 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 wy2 rxy1 c1 rxy2 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step rxy2: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: wx1 wy2 rxy1 rxy2 c1 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 wy2 rxy1 rxy2 c2 c1 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 wy2 rxy2 rxy1 c1 c2 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 wy2 rxy2 rxy1 c2 c1 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 wy2 rxy2 c2 rxy1 c1 +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step rxy1: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 wx1 rxy1 c1 rxy2 c2 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step rxy2: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c2: COMMIT; + +starting permutation: wy2 wx1 rxy1 rxy2 c1 c2 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 wx1 rxy1 rxy2 c2 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 wx1 rxy2 rxy1 c1 c2 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 wx1 rxy2 rxy1 c2 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 wx1 rxy2 c2 rxy1 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step rxy1: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 rxy2 wx1 rxy1 c1 c2 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy2 wx1 rxy1 c2 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wy2 rxy2 wx1 c2 rxy1 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step c2: COMMIT; +step rxy1: SELECT SUM(balance) FROM accounts; +ERROR: could not serialize access due to read/write dependencies among transactions +step c1: COMMIT; + +starting permutation: wy2 rxy2 c2 wx1 rxy1 c1 +step wy2: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'savings'; +step rxy2: SELECT SUM(balance) FROM accounts; + sum +---- +1000 +(1 row) + +step c2: COMMIT; +step wx1: UPDATE accounts SET balance = balance - 200 WHERE accountid = 'checking'; +step rxy1: SELECT SUM(balance) FROM accounts; +sum +--- +800 +(1 row) + +step c1: COMMIT; diff --git a/src/test/isolation/expected/truncate-conflict.out b/src/test/isolation/expected/truncate-conflict.out new file mode 100644 index 0000000..00d5ce3 --- /dev/null +++ b/src/test/isolation/expected/truncate-conflict.out @@ -0,0 +1,115 @@ +Parsed test spec with 2 sessions + +starting permutation: s1_begin s1_tab_lookup s2_auth s2_truncate s1_commit s2_reset +step s1_begin: BEGIN; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; +ERROR: permission denied for table truncate_tab +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s2_truncate s1_tab_lookup s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; +ERROR: permission denied for table truncate_tab +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s1_tab_lookup s2_truncate s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_truncate_conflict; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s2_truncate: TRUNCATE truncate_tab; +ERROR: permission denied for table truncate_tab +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s2_auth s2_truncate s1_begin s1_tab_lookup s1_commit s2_reset +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; +ERROR: permission denied for table truncate_tab +step s1_begin: BEGIN; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s1_tab_lookup s2_grant s2_auth s2_truncate s1_commit s2_reset +step s1_begin: BEGIN; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s2_grant: GRANT TRUNCATE ON truncate_tab TO regress_truncate_conflict; +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_truncate: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s2_truncate s1_tab_lookup s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: GRANT TRUNCATE ON truncate_tab TO regress_truncate_conflict; +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s1_tab_lookup s2_truncate s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: GRANT TRUNCATE ON truncate_tab TO regress_truncate_conflict; +step s2_auth: SET ROLE regress_truncate_conflict; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s2_truncate: TRUNCATE truncate_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_truncate: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s2_grant s2_auth s2_truncate s1_begin s1_tab_lookup s1_commit s2_reset +step s2_grant: GRANT TRUNCATE ON truncate_tab TO regress_truncate_conflict; +step s2_auth: SET ROLE regress_truncate_conflict; +step s2_truncate: TRUNCATE truncate_tab; +step s1_begin: BEGIN; +step s1_tab_lookup: SELECT count(*) >= 0 FROM truncate_tab; +?column? +-------- +t +(1 row) + +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; diff --git a/src/test/isolation/expected/tuplelock-conflict.out b/src/test/isolation/expected/tuplelock-conflict.out new file mode 100644 index 0000000..d629314 --- /dev/null +++ b/src/test/isolation/expected/tuplelock-conflict.out @@ -0,0 +1,629 @@ +Parsed test spec with 2 sessions + +starting permutation: s1_begin s1_lcksvpt s1_tuplock1 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock1 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock1 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock1 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock2 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock2 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock2 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock2 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock3 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_lcksvpt s1_tuplock3 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock2: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock3 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock3 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock4 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock1: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock4 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock2: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock4 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_lcksvpt s1_tuplock4 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_lcksvpt: SELECT * FROM multixact_conflict FOR KEY SHARE; SAVEPOINT foo; +a +- +1 +(1 row) + +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock1 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock1 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock1 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock1 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock2 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock2 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock2 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock2 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock3 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; +a +- +1 +(1 row) + +step s1_commit: COMMIT; + +starting permutation: s1_begin s1_tuplock3 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock2: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock3 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock3 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock4 s2_tuplock1 s1_commit +step s1_begin: BEGIN; +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock1: SELECT * FROM multixact_conflict FOR KEY SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock1: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock4 s2_tuplock2 s1_commit +step s1_begin: BEGIN; +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock2: SELECT * FROM multixact_conflict FOR SHARE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock2: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock4 s2_tuplock3 s1_commit +step s1_begin: BEGIN; +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock3: SELECT * FROM multixact_conflict FOR NO KEY UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock3: <... completed> +a +- +1 +(1 row) + + +starting permutation: s1_begin s1_tuplock4 s2_tuplock4 s1_commit +step s1_begin: BEGIN; +step s1_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; +a +- +1 +(1 row) + +step s2_tuplock4: SELECT * FROM multixact_conflict FOR UPDATE; <waiting ...> +step s1_commit: COMMIT; +step s2_tuplock4: <... completed> +a +- +1 +(1 row) + diff --git a/src/test/isolation/expected/tuplelock-partition.out b/src/test/isolation/expected/tuplelock-partition.out new file mode 100644 index 0000000..369ddf9 --- /dev/null +++ b/src/test/isolation/expected/tuplelock-partition.out @@ -0,0 +1,24 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s1update_nokey s2locktuple s1c +step s1b: BEGIN; +step s1update_nokey: INSERT INTO parttab (key, col1, col2) VALUES (1, 'a', 'b') ON CONFLICT (key) DO UPDATE SET col1 = 'x', col2 = 'y'; +step s2locktuple: SELECT * FROM parttab FOR KEY SHARE; +col1|key|col2 +----+---+---- +a | 1|b +(1 row) + +step s1c: COMMIT; + +starting permutation: s1b s1update_key s2locktuple s1c +step s1b: BEGIN; +step s1update_key: INSERT INTO parttab (key, col1, col2) VALUES (1, 'a', 'b') ON CONFLICT (key) DO UPDATE SET key=1; +step s2locktuple: SELECT * FROM parttab FOR KEY SHARE; <waiting ...> +step s1c: COMMIT; +step s2locktuple: <... completed> +col1|key|col2 +----+---+---- +a | 1|b +(1 row) + diff --git a/src/test/isolation/expected/tuplelock-update.out b/src/test/isolation/expected/tuplelock-update.out new file mode 100644 index 0000000..1d37d45 --- /dev/null +++ b/src/test/isolation/expected/tuplelock-update.out @@ -0,0 +1,49 @@ +Parsed test spec with 4 sessions + +starting permutation: s1_advlock s2_update s3_update s4_update s1_chain s1_begin s1_grablock s1_advunlock1 s1_advunlock2 s1_advunlock3 s1_commit +step s1_advlock: + SELECT pg_advisory_lock(142857), + pg_advisory_lock(285714), + pg_advisory_lock(571428); + +pg_advisory_lock|pg_advisory_lock|pg_advisory_lock +----------------+----------------+---------------- + | | +(1 row) + +step s2_update: UPDATE pktab SET data = DEFAULT WHERE pg_advisory_lock_shared(142857) IS NOT NULL; <waiting ...> +step s3_update: UPDATE pktab SET data = DEFAULT WHERE pg_advisory_lock_shared(285714) IS NOT NULL; <waiting ...> +step s4_update: UPDATE pktab SET data = DEFAULT WHERE pg_advisory_lock_shared(571428) IS NOT NULL; <waiting ...> +step s1_chain: UPDATE pktab SET data = DEFAULT; +step s1_begin: BEGIN; +step s1_grablock: SELECT * FROM pktab FOR KEY SHARE; +id|data +--+---- + 1| 2 +(1 row) + +step s1_advunlock1: SELECT pg_advisory_unlock(142857); <waiting ...> +step s2_update: <... completed> +step s1_advunlock1: <... completed> +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_advunlock2: SELECT pg_advisory_unlock(285714); <waiting ...> +step s3_update: <... completed> +step s1_advunlock2: <... completed> +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_advunlock3: SELECT pg_advisory_unlock(571428); <waiting ...> +step s4_update: <... completed> +step s1_advunlock3: <... completed> +pg_advisory_unlock +------------------ +t +(1 row) + +step s1_commit: COMMIT; diff --git a/src/test/isolation/expected/tuplelock-upgrade-no-deadlock.out b/src/test/isolation/expected/tuplelock-upgrade-no-deadlock.out new file mode 100644 index 0000000..2159092 --- /dev/null +++ b/src/test/isolation/expected/tuplelock-upgrade-no-deadlock.out @@ -0,0 +1,253 @@ +Parsed test spec with 4 sessions + +starting permutation: s1_share s2_for_update s3_share s3_for_update s1_rollback s3_rollback s2_rollback +step s1_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s3_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s1_rollback: rollback; +step s3_for_update: <... completed> +id +-- + 1 +(1 row) + +step s3_rollback: rollback; +step s2_for_update: <... completed> +id +-- + 1 +(1 row) + +step s2_rollback: rollback; + +starting permutation: s1_keyshare s2_for_update s3_keyshare s1_update s3_update s1_rollback s3_rollback s2_rollback +step s1_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s1_update: update tlu_job set name = 'b' where id = 1; +step s3_update: update tlu_job set name = 'c' where id = 1; <waiting ...> +step s1_rollback: rollback; +step s3_update: <... completed> +step s3_rollback: rollback; +step s2_for_update: <... completed> +id +-- + 1 +(1 row) + +step s2_rollback: rollback; + +starting permutation: s1_keyshare s2_for_update s3_keyshare s1_update s3_update s1_commit s3_rollback s2_rollback +step s1_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s1_update: update tlu_job set name = 'b' where id = 1; +step s3_update: update tlu_job set name = 'c' where id = 1; <waiting ...> +step s1_commit: commit; +step s3_update: <... completed> +step s3_rollback: rollback; +step s2_for_update: <... completed> +id +-- + 1 +(1 row) + +step s2_rollback: rollback; + +starting permutation: s1_keyshare s2_for_update s3_keyshare s3_delete s1_rollback s3_rollback s2_rollback +step s1_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s3_delete: delete from tlu_job where id = 1; <waiting ...> +step s1_rollback: rollback; +step s3_delete: <... completed> +step s3_rollback: rollback; +step s2_for_update: <... completed> +id +-- + 1 +(1 row) + +step s2_rollback: rollback; + +starting permutation: s1_keyshare s2_for_update s3_keyshare s3_delete s1_rollback s3_commit s2_rollback +step s1_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s3_delete: delete from tlu_job where id = 1; <waiting ...> +step s1_rollback: rollback; +step s3_delete: <... completed> +step s3_commit: commit; +step s2_for_update: <... completed> +id +-- +(0 rows) + +step s2_rollback: rollback; + +starting permutation: s1_share s2_for_update s3_for_update s1_rollback s2_rollback s3_rollback +step s1_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s2_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s3_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s1_rollback: rollback; +step s2_for_update: <... completed> +id +-- + 1 +(1 row) + +step s2_rollback: rollback; +step s3_for_update: <... completed> +id +-- + 1 +(1 row) + +step s3_rollback: rollback; + +starting permutation: s1_share s2_update s3_update s1_rollback s2_rollback s3_rollback +step s1_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s2_update: update tlu_job set name = 'b' where id = 1; <waiting ...> +step s3_update: update tlu_job set name = 'c' where id = 1; <waiting ...> +step s1_rollback: rollback; +step s2_update: <... completed> +step s2_rollback: rollback; +step s3_update: <... completed> +step s3_rollback: rollback; + +starting permutation: s1_share s2_delete s3_delete s1_rollback s2_rollback s3_rollback +step s1_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s2_delete: delete from tlu_job where id = 1; <waiting ...> +step s3_delete: delete from tlu_job where id = 1; <waiting ...> +step s1_rollback: rollback; +step s2_delete: <... completed> +step s2_rollback: rollback; +step s3_delete: <... completed> +step s3_rollback: rollback; + +starting permutation: s1_keyshare s3_for_update s2_for_keyshare s1_savept_e s1_share s1_savept_f s1_fornokeyupd s2_fornokeyupd s0_begin s0_keyshare s1_rollback_f s0_keyshare s1_rollback_e s1_rollback s2_rollback s0_rollback s3_rollback +step s1_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s3_for_update: select id from tlu_job where id = 1 for update; <waiting ...> +step s2_for_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s1_savept_e: savepoint s1_e; +step s1_share: select id from tlu_job where id = 1 for share; +id +-- + 1 +(1 row) + +step s1_savept_f: savepoint s1_f; +step s1_fornokeyupd: select id from tlu_job where id = 1 for no key update; +id +-- + 1 +(1 row) + +step s2_fornokeyupd: select id from tlu_job where id = 1 for no key update; <waiting ...> +step s0_begin: begin; +step s0_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s1_rollback_f: rollback to s1_f; +step s0_keyshare: select id from tlu_job where id = 1 for key share; +id +-- + 1 +(1 row) + +step s1_rollback_e: rollback to s1_e; +step s2_fornokeyupd: <... completed> +id +-- + 1 +(1 row) + +step s1_rollback: rollback; +step s2_rollback: rollback; +step s0_rollback: rollback; +step s3_for_update: <... completed> +id +-- + 1 +(1 row) + +step s3_rollback: rollback; diff --git a/src/test/isolation/expected/two-ids.out b/src/test/isolation/expected/two-ids.out new file mode 100644 index 0000000..2ebd73f --- /dev/null +++ b/src/test/isolation/expected/two-ids.out @@ -0,0 +1,1187 @@ +Parsed test spec with 3 sessions + +starting permutation: wx1 c1 rxwy2 c2 ry3 c3 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 3 +(1 row) + +step c3: COMMIT; + +starting permutation: wx1 c1 rxwy2 ry3 c2 c3 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 c1 rxwy2 ry3 c3 c2 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 c1 ry3 rxwy2 c2 c3 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 c1 ry3 rxwy2 c3 c2 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 c1 ry3 c3 rxwy2 c2 +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: wx1 rxwy2 c1 c2 ry3 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; + +starting permutation: wx1 rxwy2 c1 ry3 c2 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: wx1 rxwy2 c1 ry3 c3 c2 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 rxwy2 c2 c1 ry3 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; + +starting permutation: wx1 rxwy2 c2 ry3 c1 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 rxwy2 c2 ry3 c3 c1 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx1 rxwy2 ry3 c1 c2 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: wx1 rxwy2 ry3 c1 c3 c2 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 rxwy2 ry3 c2 c1 c3 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 rxwy2 ry3 c2 c3 c1 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx1 rxwy2 ry3 c3 c1 c2 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 rxwy2 ry3 c3 c2 c1 +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx1 ry3 c1 rxwy2 c2 c3 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 ry3 c1 rxwy2 c3 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 ry3 c1 c3 rxwy2 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: wx1 ry3 rxwy2 c1 c2 c3 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: wx1 ry3 rxwy2 c1 c3 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: wx1 ry3 rxwy2 c2 c1 c3 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: wx1 ry3 rxwy2 c2 c3 c1 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: wx1 ry3 rxwy2 c3 c1 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 ry3 rxwy2 c3 c2 c1 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: wx1 ry3 c3 c1 rxwy2 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: wx1 ry3 c3 rxwy2 c1 c2 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: wx1 ry3 c3 rxwy2 c2 c1 +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 wx1 c1 c2 ry3 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; + +starting permutation: rxwy2 wx1 c1 ry3 c2 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: rxwy2 wx1 c1 ry3 c3 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxwy2 wx1 c2 c1 ry3 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; + +starting permutation: rxwy2 wx1 c2 ry3 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 wx1 c2 ry3 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 wx1 ry3 c1 c2 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: rxwy2 wx1 ry3 c1 c3 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxwy2 wx1 ry3 c2 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 wx1 ry3 c2 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 wx1 ry3 c3 c1 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy2 wx1 ry3 c3 c2 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 c2 wx1 c1 ry3 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; + +starting permutation: rxwy2 c2 wx1 ry3 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 c2 wx1 ry3 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 c2 ry3 wx1 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 c2 ry3 wx1 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 c2 ry3 c3 wx1 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step ry3: select id from D2; +id +-- + 2 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 wx1 c1 c2 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: rxwy2 ry3 wx1 c1 c3 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: rxwy2 ry3 wx1 c2 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 ry3 wx1 c2 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 wx1 c3 c1 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy2 ry3 wx1 c3 c2 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 c2 wx1 c1 c3 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: rxwy2 ry3 c2 wx1 c3 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 c2 c3 wx1 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c2: COMMIT; +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 c3 wx1 c1 c2 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: rxwy2 ry3 c3 wx1 c2 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: rxwy2 ry3 c3 c2 wx1 c1 +step rxwy2: update D2 set id = (select id+1 from D1); +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; + +starting permutation: ry3 wx1 c1 rxwy2 c2 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; + +starting permutation: ry3 wx1 c1 rxwy2 c3 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 wx1 c1 c3 rxwy2 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: ry3 wx1 rxwy2 c1 c2 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: ry3 wx1 rxwy2 c1 c3 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry3 wx1 rxwy2 c2 c1 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: ry3 wx1 rxwy2 c2 c3 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 wx1 rxwy2 c3 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 wx1 rxwy2 c3 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 wx1 c3 c1 rxwy2 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: ry3 wx1 c3 rxwy2 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 wx1 c3 rxwy2 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 wx1 c1 c2 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions +step c3: COMMIT; + +starting permutation: ry3 rxwy2 wx1 c1 c3 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; +step c2: COMMIT; +ERROR: could not serialize access due to read/write dependencies among transactions + +starting permutation: ry3 rxwy2 wx1 c2 c1 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: ry3 rxwy2 wx1 c2 c3 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 wx1 c3 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 rxwy2 wx1 c3 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 c2 wx1 c1 c3 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c3: COMMIT; + +starting permutation: ry3 rxwy2 c2 wx1 c3 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c3: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 c2 c3 wx1 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 c3 wx1 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 rxwy2 c3 wx1 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 rxwy2 c3 c2 wx1 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step rxwy2: update D2 set id = (select id+1 from D1); +step c3: COMMIT; +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; + +starting permutation: ry3 c3 wx1 c1 rxwy2 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; + +starting permutation: ry3 c3 wx1 rxwy2 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 c3 wx1 rxwy2 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step wx1: update D1 set id = id + 1; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 c3 rxwy2 wx1 c1 c2 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c1: COMMIT; +step c2: COMMIT; + +starting permutation: ry3 c3 rxwy2 wx1 c2 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step wx1: update D1 set id = id + 1; +step c2: COMMIT; +step c1: COMMIT; + +starting permutation: ry3 c3 rxwy2 c2 wx1 c1 +step ry3: select id from D2; +id +-- + 1 +(1 row) + +step c3: COMMIT; +step rxwy2: update D2 set id = (select id+1 from D1); +step c2: COMMIT; +step wx1: update D1 set id = id + 1; +step c1: COMMIT; diff --git a/src/test/isolation/expected/update-conflict-out.out b/src/test/isolation/expected/update-conflict-out.out new file mode 100644 index 0000000..1e82bd4 --- /dev/null +++ b/src/test/isolation/expected/update-conflict-out.out @@ -0,0 +1,31 @@ +Parsed test spec with 3 sessions + +starting permutation: foo_select bar_insert foo_insert foo_commit trouble_update bar_select bar_commit trouble_abort +step foo_select: SELECT * FROM txn0 WHERE id = 42; +id|val +--+--- +(0 rows) + +step bar_insert: INSERT INTO txn0 SELECT 42, 'bar_insert'; +step foo_insert: INSERT INTO txn1 SELECT 7, 'foo_insert'; +step foo_commit: COMMIT; +step trouble_update: UPDATE txn1 SET val = 'add physical version for "bar_select"' WHERE id = 7; +step bar_select: SELECT * FROM txn1 WHERE id = 7; +ERROR: could not serialize access due to read/write dependencies among transactions +step bar_commit: COMMIT; +step trouble_abort: ABORT; + +starting permutation: foo_select bar_insert foo_insert foo_commit trouble_delete bar_select bar_commit trouble_abort +step foo_select: SELECT * FROM txn0 WHERE id = 42; +id|val +--+--- +(0 rows) + +step bar_insert: INSERT INTO txn0 SELECT 42, 'bar_insert'; +step foo_insert: INSERT INTO txn1 SELECT 7, 'foo_insert'; +step foo_commit: COMMIT; +step trouble_delete: DELETE FROM txn1 WHERE id = 7; +step bar_select: SELECT * FROM txn1 WHERE id = 7; +ERROR: could not serialize access due to read/write dependencies among transactions +step bar_commit: COMMIT; +step trouble_abort: ABORT; diff --git a/src/test/isolation/expected/update-locked-tuple.out b/src/test/isolation/expected/update-locked-tuple.out new file mode 100644 index 0000000..1982c75 --- /dev/null +++ b/src/test/isolation/expected/update-locked-tuple.out @@ -0,0 +1,55 @@ +Parsed test spec with 2 sessions + +starting permutation: s1b s2b s2u s2c s1u1 s1u2 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s2c: COMMIT; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s1c: COMMIT; + +starting permutation: s1b s2b s2u s1u1 s2c s1u2 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s2c: COMMIT; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s1c: COMMIT; + +starting permutation: s1b s2b s1u1 s2u s2c s1u2 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s2c: COMMIT; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s1c: COMMIT; + +starting permutation: s1b s1u1 s2b s2u s2c s1u2 s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s2c: COMMIT; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s1c: COMMIT; + +starting permutation: s1b s1u1 s2b s1u2 s2u s2c s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s2c: COMMIT; +step s1c: COMMIT; + +starting permutation: s1b s1u1 s1u2 s2b s2u s2c s1c +step s1b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s1u1: UPDATE orders SET name = 'order of olivier (2)', user_id = 1 WHERE id = 1; +step s1u2: UPDATE orders SET name = 'order of olivier (3)', user_id = 1 WHERE id = 1; +step s2b: BEGIN ISOLATION LEVEL REPEATABLE READ; +step s2u: UPDATE users SET sometime = '1830-10-04' WHERE id = 1; +step s2c: COMMIT; +step s1c: COMMIT; diff --git a/src/test/isolation/expected/vacuum-concurrent-drop.out b/src/test/isolation/expected/vacuum-concurrent-drop.out new file mode 100644 index 0000000..cf348d7 --- /dev/null +++ b/src/test/isolation/expected/vacuum-concurrent-drop.out @@ -0,0 +1,76 @@ +Parsed test spec with 2 sessions + +starting permutation: lock vac_specified drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_specified: VACUUM part1, part2; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +s2: WARNING: skipping vacuum of "part2" --- relation no longer exists +step vac_specified: <... completed> + +starting permutation: lock vac_all_parts drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_all_parts: VACUUM parted; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +step vac_all_parts: <... completed> + +starting permutation: lock analyze_specified drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step analyze_specified: ANALYZE part1, part2; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +s2: WARNING: skipping analyze of "part2" --- relation no longer exists +step analyze_specified: <... completed> + +starting permutation: lock analyze_all_parts drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step analyze_all_parts: ANALYZE parted; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +step analyze_all_parts: <... completed> + +starting permutation: lock vac_analyze_specified drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_analyze_specified: VACUUM ANALYZE part1, part2; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +s2: WARNING: skipping vacuum of "part2" --- relation no longer exists +step vac_analyze_specified: <... completed> + +starting permutation: lock vac_analyze_all_parts drop_and_commit +step lock: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_analyze_all_parts: VACUUM ANALYZE parted; <waiting ...> +step drop_and_commit: + DROP TABLE part2; + COMMIT; + +step vac_analyze_all_parts: <... completed> diff --git a/src/test/isolation/expected/vacuum-conflict.out b/src/test/isolation/expected/vacuum-conflict.out new file mode 100644 index 0000000..ffde537 --- /dev/null +++ b/src/test/isolation/expected/vacuum-conflict.out @@ -0,0 +1,149 @@ +Parsed test spec with 2 sessions + +starting permutation: s1_begin s1_lock s2_auth s2_vacuum s1_commit s2_reset +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can vacuum it +step s2_vacuum: VACUUM vacuum_tab; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s2_vacuum s1_lock s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can vacuum it +step s2_vacuum: VACUUM vacuum_tab; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s1_lock s2_vacuum s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can vacuum it +step s2_vacuum: VACUUM vacuum_tab; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s2_auth s2_vacuum s1_begin s1_lock s1_commit s2_reset +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can vacuum it +step s2_vacuum: VACUUM vacuum_tab; +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s1_lock s2_auth s2_analyze s1_commit s2_reset +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can analyze it +step s2_analyze: ANALYZE vacuum_tab; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s2_analyze s1_lock s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can analyze it +step s2_analyze: ANALYZE vacuum_tab; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_auth s1_lock s2_analyze s1_commit s2_reset +step s1_begin: BEGIN; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can analyze it +step s2_analyze: ANALYZE vacuum_tab; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s2_auth s2_analyze s1_begin s1_lock s1_commit s2_reset +step s2_auth: SET ROLE regress_vacuum_conflict; +s2: WARNING: skipping "vacuum_tab" --- only table or database owner can analyze it +step s2_analyze: ANALYZE vacuum_tab; +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s1_lock s2_auth s2_vacuum s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_vacuum: VACUUM vacuum_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_vacuum: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s2_vacuum s1_lock s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_vacuum: VACUUM vacuum_tab; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s1_lock s2_vacuum s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_vacuum: VACUUM vacuum_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_vacuum: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s2_grant s2_auth s2_vacuum s1_begin s1_lock s1_commit s2_reset +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_vacuum: VACUUM vacuum_tab; +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s1_lock s2_auth s2_analyze s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_analyze: ANALYZE vacuum_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_analyze: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s2_analyze s1_lock s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_analyze: ANALYZE vacuum_tab; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; + +starting permutation: s1_begin s2_grant s2_auth s1_lock s2_analyze s1_commit s2_reset +step s1_begin: BEGIN; +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s2_analyze: ANALYZE vacuum_tab; <waiting ...> +step s1_commit: COMMIT; +step s2_analyze: <... completed> +step s2_reset: RESET ROLE; + +starting permutation: s2_grant s2_auth s2_analyze s1_begin s1_lock s1_commit s2_reset +step s2_grant: ALTER TABLE vacuum_tab OWNER TO regress_vacuum_conflict; +step s2_auth: SET ROLE regress_vacuum_conflict; +step s2_analyze: ANALYZE vacuum_tab; +step s1_begin: BEGIN; +step s1_lock: LOCK vacuum_tab IN SHARE UPDATE EXCLUSIVE MODE; +step s1_commit: COMMIT; +step s2_reset: RESET ROLE; diff --git a/src/test/isolation/expected/vacuum-reltuples.out b/src/test/isolation/expected/vacuum-reltuples.out new file mode 100644 index 0000000..cdbe7f3 --- /dev/null +++ b/src/test/isolation/expected/vacuum-reltuples.out @@ -0,0 +1,67 @@ +Parsed test spec with 2 sessions + +starting permutation: modify vac stats +step modify: + insert into smalltbl select max(id)+1 from smalltbl; + +step vac: + vacuum smalltbl; + +step stats: + select relpages, reltuples from pg_class + where oid='smalltbl'::regclass; + +relpages|reltuples +--------+--------- + 1| 21 +(1 row) + + +starting permutation: modify open fetch1 vac close stats +step modify: + insert into smalltbl select max(id)+1 from smalltbl; + +step open: + begin; + declare c1 cursor for select 1 as dummy from smalltbl; + +step fetch1: + fetch next from c1; + +dummy +----- + 1 +(1 row) + +step vac: + vacuum smalltbl; + +step close: + commit; + +step stats: + select relpages, reltuples from pg_class + where oid='smalltbl'::regclass; + +relpages|reltuples +--------+--------- + 1| 20 +(1 row) + + +starting permutation: modify vac stats +step modify: + insert into smalltbl select max(id)+1 from smalltbl; + +step vac: + vacuum smalltbl; + +step stats: + select relpages, reltuples from pg_class + where oid='smalltbl'::regclass; + +relpages|reltuples +--------+--------- + 1| 21 +(1 row) + diff --git a/src/test/isolation/expected/vacuum-skip-locked.out b/src/test/isolation/expected/vacuum-skip-locked.out new file mode 100644 index 0000000..99db281 --- /dev/null +++ b/src/test/isolation/expected/vacuum-skip-locked.out @@ -0,0 +1,171 @@ +Parsed test spec with 2 sessions + +starting permutation: lock_share vac_specified commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_specified: VACUUM (SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_share vac_all_parts commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_all_parts: VACUUM (SKIP_LOCKED) parted; +step commit: + COMMIT; + + +starting permutation: lock_share analyze_specified commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +s2: WARNING: skipping analyze of "part1" --- lock not available +step analyze_specified: ANALYZE (SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_share analyze_all_parts commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +step analyze_all_parts: ANALYZE (SKIP_LOCKED) parted; +step commit: + COMMIT; + + +starting permutation: lock_share vac_analyze_specified commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_analyze_specified: VACUUM (ANALYZE, SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_share vac_analyze_all_parts commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_analyze_all_parts: VACUUM (ANALYZE, SKIP_LOCKED) parted; +step commit: + COMMIT; + + +starting permutation: lock_share vac_full_specified commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_full_specified: VACUUM (SKIP_LOCKED, FULL) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_share vac_full_all_parts commit +step lock_share: + BEGIN; + LOCK part1 IN SHARE MODE; + +step vac_full_all_parts: VACUUM (SKIP_LOCKED, FULL) parted; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive vac_specified commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_specified: VACUUM (SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive vac_all_parts commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +step vac_all_parts: VACUUM (SKIP_LOCKED) parted; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive analyze_specified commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +s2: WARNING: skipping analyze of "part1" --- lock not available +step analyze_specified: ANALYZE (SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive analyze_all_parts commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +step analyze_all_parts: ANALYZE (SKIP_LOCKED) parted; <waiting ...> +step commit: + COMMIT; + +step analyze_all_parts: <... completed> + +starting permutation: lock_access_exclusive vac_analyze_specified commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_analyze_specified: VACUUM (ANALYZE, SKIP_LOCKED) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive vac_analyze_all_parts commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +step vac_analyze_all_parts: VACUUM (ANALYZE, SKIP_LOCKED) parted; <waiting ...> +step commit: + COMMIT; + +step vac_analyze_all_parts: <... completed> + +starting permutation: lock_access_exclusive vac_full_specified commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +s2: WARNING: skipping vacuum of "part1" --- lock not available +step vac_full_specified: VACUUM (SKIP_LOCKED, FULL) part1, part2; +step commit: + COMMIT; + + +starting permutation: lock_access_exclusive vac_full_all_parts commit +step lock_access_exclusive: + BEGIN; + LOCK part1 IN ACCESS EXCLUSIVE MODE; + +step vac_full_all_parts: VACUUM (SKIP_LOCKED, FULL) parted; +step commit: + COMMIT; + |