Parsed test spec with 2 sessions

starting permutation: s1-load-cache s1-insert s1-begin s1-select s2-begin s2-move-placement s1-update s2-commit s1-commit s2-print-content s2-print-placements
step s1-load-cache:
 TRUNCATE test_move_placement;

step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    1
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-update:
 UPDATE test_move_placement SET y = 5 WHERE x = 5;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-update: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     5
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-load-cache s1-insert s1-begin s1-select s2-begin s2-move-placement s1-delete s2-commit s1-commit s2-print-content s2-print-placements
step s1-load-cache:
 TRUNCATE test_move_placement;

step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    1
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-delete:
 DELETE FROM test_move_placement WHERE x = 5;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-delete: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-load-cache s1-begin s1-select s2-begin s2-move-placement s1-insert s2-commit s1-commit s2-print-content s2-print-placements
step s1-load-cache:
 TRUNCATE test_move_placement;

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-insert: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |    10
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-load-cache s1-begin s1-select s2-begin s2-move-placement s1-copy s2-commit s1-commit s2-print-content s2-print-placements
step s1-load-cache:
 TRUNCATE test_move_placement;

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-copy:
 COPY test_move_placement FROM PROGRAM 'echo "1,1\n2,2\n3,3\n4,4\n5,5"' WITH CSV;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-copy: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     5
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-load-cache s1-begin s1-select s2-begin s2-move-placement s1-ddl s2-commit s1-commit s2-print-index-count s2-print-placements
step s1-load-cache:
 TRUNCATE test_move_placement;

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-ddl:
 CREATE INDEX test_move_placement_index ON test_move_placement(x);
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-ddl: <... completed>
step s1-commit:
 COMMIT;

step s2-print-index-count:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select count(*) from pg_indexes WHERE tablename = ''%s''')
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57638|t      |     1
   57638|t      |     1
   57638|t      |     1
(8 rows)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-insert s1-begin s1-select s2-begin s2-move-placement s1-update s2-commit s1-commit s2-print-content s2-print-placements
step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    1
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-update:
 UPDATE test_move_placement SET y = 5 WHERE x = 5;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-update: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     5
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-insert s1-begin s1-select s2-begin s2-move-placement s1-delete s2-commit s1-commit s2-print-content s2-print-placements
step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);

step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    1
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-delete:
 DELETE FROM test_move_placement WHERE x = 5;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-delete: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-begin s1-select s2-begin s2-move-placement s1-insert s2-commit s1-commit s2-print-content s2-print-placements
step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-insert:
 INSERT INTO test_move_placement VALUES (5, 10);
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-insert: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |    10
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-begin s1-select s2-begin s2-move-placement s1-copy s2-commit s1-commit s2-print-content s2-print-placements
step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-copy:
 COPY test_move_placement FROM PROGRAM 'echo "1,1\n2,2\n3,3\n4,4\n5,5"' WITH CSV;
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-copy: <... completed>
step s1-commit:
 COMMIT;

step s2-print-content:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select y from %s WHERE x = 5')
 WHERE
  shardid IN (SELECT * FROM selected_shard)
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     5
(1 row)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)


starting permutation: s1-begin s1-select s2-begin s2-move-placement s1-ddl s2-commit s1-commit s2-print-index-count s2-print-placements
step s1-begin:
    BEGIN;
    -- the tests are written with the logic where single shard SELECTs
    -- do not to open transaction blocks
    SET citus.select_opens_transaction_block TO false;

step s1-select:
 SELECT count(*) FROM test_move_placement WHERE x = 5;

count
---------------------------------------------------------------------
    0
(1 row)

step s2-begin:
 BEGIN;

step s2-move-placement:
 SELECT master_move_shard_placement((SELECT * FROM selected_shard), 'localhost', 57638, 'localhost', 57637, 'force_logical');

master_move_shard_placement
---------------------------------------------------------------------

(1 row)

step s1-ddl:
 CREATE INDEX test_move_placement_index ON test_move_placement(x);
 <waiting ...>
step s2-commit: 
 COMMIT;

step s1-ddl: <... completed>
step s1-commit:
 COMMIT;

step s2-print-index-count:
 SELECT
  nodeport, success, result
 FROM
  run_command_on_placements('test_move_placement', 'select count(*) from pg_indexes WHERE tablename = ''%s''')
 ORDER BY
  nodeport;

nodeport|success|result
---------------------------------------------------------------------
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57637|t      |     1
   57638|t      |     1
   57638|t      |     1
   57638|t      |     1
(8 rows)

step s2-print-placements:
 SELECT
  nodename, nodeport, count(*)
 FROM
  pg_dist_shard_placement
 WHERE
  shardid IN (SELECT shardid FROM pg_dist_shard WHERE logicalrelid = 'test_move_placement'::regclass)
 AND
  shardstate = 1
 GROUP BY
  nodename, nodeport;

nodename |nodeport|count
---------------------------------------------------------------------
localhost|   57637|    5
localhost|   57638|    3
(2 rows)