77 lines
2.6 KiB
Python
77 lines
2.6 KiB
Python
# Test that a row that ends up in a new partition contains changes made by
|
|
# a concurrent transaction.
|
|
|
|
setup
|
|
{
|
|
--
|
|
-- Setup to test concurrent handling of ExecDelete().
|
|
--
|
|
CREATE TABLE foo (a int, b text) PARTITION BY LIST(a);
|
|
CREATE TABLE foo1 PARTITION OF foo FOR VALUES IN (1);
|
|
CREATE TABLE foo2 PARTITION OF foo FOR VALUES IN (2);
|
|
INSERT INTO foo VALUES (1, 'ABC');
|
|
|
|
--
|
|
-- Setup to test concurrent handling of GetTupleForTrigger().
|
|
--
|
|
CREATE TABLE footrg (a int, b text) PARTITION BY LIST(a);
|
|
CREATE TABLE triglog as select * from footrg;
|
|
CREATE TABLE footrg1 PARTITION OF footrg FOR VALUES IN (1);
|
|
CREATE TABLE footrg2 PARTITION OF footrg FOR VALUES IN (2);
|
|
INSERT INTO footrg VALUES (1, 'ABC');
|
|
CREATE FUNCTION func_footrg() RETURNS TRIGGER AS $$
|
|
BEGIN
|
|
OLD.b = OLD.b || ' trigger';
|
|
|
|
-- This will verify that the trigger is not run *before* the row is
|
|
-- refetched by EvalPlanQual. The OLD row should contain the changes made
|
|
-- by the concurrent session.
|
|
INSERT INTO triglog select OLD.*;
|
|
|
|
RETURN OLD;
|
|
END $$ LANGUAGE PLPGSQL;
|
|
CREATE TRIGGER footrg_ondel BEFORE DELETE ON footrg1
|
|
FOR EACH ROW EXECUTE PROCEDURE func_footrg();
|
|
|
|
}
|
|
|
|
teardown
|
|
{
|
|
DROP TABLE foo;
|
|
DROP TRIGGER footrg_ondel ON footrg1;
|
|
DROP FUNCTION func_footrg();
|
|
DROP TABLE footrg;
|
|
DROP TABLE triglog;
|
|
}
|
|
|
|
session s1
|
|
step s1b { BEGIN ISOLATION LEVEL READ COMMITTED; }
|
|
step s1u { UPDATE foo SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; }
|
|
step s1ut { UPDATE footrg SET a = a + 1, b = b || ' update1' WHERE b like '%ABC%'; }
|
|
step s1s { SELECT tableoid::regclass, * FROM foo ORDER BY a; }
|
|
step s1st { SELECT tableoid::regclass, * FROM footrg ORDER BY a; }
|
|
step s1stl { SELECT * FROM triglog ORDER BY a; }
|
|
step s1c { COMMIT; }
|
|
|
|
session s2
|
|
step s2b { BEGIN ISOLATION LEVEL READ COMMITTED; }
|
|
step s2u1 { UPDATE foo SET b = b || ' update2' WHERE a = 1; }
|
|
step s2u2 { UPDATE foo SET b = 'EFG' WHERE a = 1; }
|
|
step s2ut1 { UPDATE footrg SET b = b || ' update2' WHERE a = 1; }
|
|
step s2ut2 { UPDATE footrg SET b = 'EFG' WHERE a = 1; }
|
|
step s2c { COMMIT; }
|
|
|
|
|
|
# Session s1 is moving a row into another partition, but is waiting for
|
|
# another session s2 that is updating the original row. The row that ends up
|
|
# in the new partition should contain the changes made by session s2.
|
|
permutation s1b s2b s2u1 s1u s2c s1c s1s
|
|
|
|
# Same as above, except, session s1 is waiting in GetTupleForTrigger().
|
|
permutation s1b s2b s2ut1 s1ut s2c s1c s1st s1stl
|
|
|
|
# Below two cases are similar to the above two; except that the session s1
|
|
# fails EvalPlanQual() test, so partition key update does not happen.
|
|
permutation s1b s2b s2u2 s1u s2c s1c s1s
|
|
permutation s1b s2b s2ut2 s1ut s2c s1c s1st s1stl
|