mirror of
https://github.com/postgres/postgres.git
synced 2026-04-15 22:10:45 -04:00
04a4c03efe
Discussion: https://postgr.es/m/20191004222437.45qmglpto43pd3jb@alap3.anarazel.de Backpatch: 9.6-, just likec884119950and6e61d75f52
2204 lines
91 KiB
Text
2204 lines
91 KiB
Text
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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 in steps s1_c s2_ins_a: 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
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-a val-a-s2
|
|
|
|
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
|
|
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
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
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
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-a val-a-s1-upserts2
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-a val-a-upss2
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-a val-a-s1-ups1-upserts2
|
|
|
|
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
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-a val-a-upss2
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
|
|
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
|
|
step s1_ins_c: INSERT INTO trigtest VALUES ('key-c', 'val-c-s1') RETURNING *;
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-c val-c-s1
|
|
|
|
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
|
|
step s1_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rc: BEGIN ISOLATION LEVEL READ COMMITTED; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
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
|
|
step s1_c: COMMIT;
|
|
step s2_upd_b_data: <... completed>
|
|
key data
|
|
|
|
step s2_c: COMMIT;
|
|
step s0_rep: SELECT * FROM trigtest ORDER BY key, data
|
|
key data
|
|
|
|
key-b val-a-s1-tobs1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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 in steps s1_c s2_upd_a_data: 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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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 in steps s1_c s2_upd_a_data: 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-b val-b-s1
|
|
|
|
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
|
|
step s1_ins_b: INSERT INTO trigtest VALUES ('key-b', 'val-b-s1') RETURNING *;
|
|
key data
|
|
|
|
key-b val-b-s1
|
|
step s1_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
step s2_b_rr: BEGIN ISOLATION LEVEL REPEATABLE READ; SELECT 1;
|
|
?column?
|
|
|
|
1
|
|
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
|
|
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
|
|
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
|