-- -- TRIGGERS -- create table pkeys (pkey1 int4 not null, pkey2 text not null); create table fkeys (fkey1 int4, fkey2 text, fkey3 int); create table fkeys2 (fkey21 int4, fkey22 text, pkey23 int not null); create index fkeys_i on fkeys (fkey1, fkey2); create index fkeys2_i on fkeys2 (fkey21, fkey22); create index fkeys2p_i on fkeys2 (pkey23); insert into pkeys values (10, '1'); insert into pkeys values (20, '2'); insert into pkeys values (30, '3'); insert into pkeys values (40, '4'); insert into pkeys values (50, '5'); insert into pkeys values (60, '6'); create unique index pkeys_i on pkeys (pkey1, pkey2); -- -- For fkeys: -- (fkey1, fkey2) --> pkeys (pkey1, pkey2) -- (fkey3) --> fkeys2 (pkey23) -- create trigger check_fkeys_pkey_exist before insert or update on fkeys for each row execute procedure check_primary_key ('fkey1', 'fkey2', 'pkeys', 'pkey1', 'pkey2'); create trigger check_fkeys_pkey2_exist before insert or update on fkeys for each row execute procedure check_primary_key ('fkey3', 'fkeys2', 'pkey23'); -- -- For fkeys2: -- (fkey21, fkey22) --> pkeys (pkey1, pkey2) -- create trigger check_fkeys2_pkey_exist before insert or update on fkeys2 for each row execute procedure check_primary_key ('fkey21', 'fkey22', 'pkeys', 'pkey1', 'pkey2'); -- Test comments COMMENT ON TRIGGER check_fkeys2_pkey_bad ON fkeys2 IS 'wrong'; ERROR: trigger "check_fkeys2_pkey_bad" for table "fkeys2" does not exist COMMENT ON TRIGGER check_fkeys2_pkey_exist ON fkeys2 IS 'right'; COMMENT ON TRIGGER check_fkeys2_pkey_exist ON fkeys2 IS NULL; -- -- For pkeys: -- ON DELETE/UPDATE (pkey1, pkey2) CASCADE: -- fkeys (fkey1, fkey2) and fkeys2 (fkey21, fkey22) -- create trigger check_pkeys_fkey_cascade before delete or update on pkeys for each row execute procedure check_foreign_key (2, 'cascade', 'pkey1', 'pkey2', 'fkeys', 'fkey1', 'fkey2', 'fkeys2', 'fkey21', 'fkey22'); -- -- For fkeys2: -- ON DELETE/UPDATE (pkey23) RESTRICT: -- fkeys (fkey3) -- create trigger check_fkeys2_fkey_restrict before delete or update on fkeys2 for each row execute procedure check_foreign_key (1, 'restrict', 'pkey23', 'fkeys', 'fkey3'); insert into fkeys2 values (10, '1', 1); insert into fkeys2 values (30, '3', 2); insert into fkeys2 values (40, '4', 5); insert into fkeys2 values (50, '5', 3); -- no key in pkeys insert into fkeys2 values (70, '5', 3); ERROR: tuple references non-existent key DETAIL: Trigger "check_fkeys2_pkey_exist" found tuple referencing non-existent key in "pkeys". insert into fkeys values (10, '1', 2); insert into fkeys values (30, '3', 3); insert into fkeys values (40, '4', 2); insert into fkeys values (50, '5', 2); -- no key in pkeys insert into fkeys values (70, '5', 1); ERROR: tuple references non-existent key DETAIL: Trigger "check_fkeys_pkey_exist" found tuple referencing non-existent key in "pkeys". -- no key in fkeys2 insert into fkeys values (60, '6', 4); ERROR: tuple references non-existent key DETAIL: Trigger "check_fkeys_pkey2_exist" found tuple referencing non-existent key in "fkeys2". delete from pkeys where pkey1 = 30 and pkey2 = '3'; NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys are deleted ERROR: "check_fkeys2_fkey_restrict": tuple is referenced in "fkeys" CONTEXT: SQL statement "delete from fkeys2 where fkey21 = $1 and fkey22 = $2 " delete from pkeys where pkey1 = 40 and pkey2 = '4'; NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys are deleted NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys2 are deleted update pkeys set pkey1 = 7, pkey2 = '70' where pkey1 = 50 and pkey2 = '5'; NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys are deleted ERROR: "check_fkeys2_fkey_restrict": tuple is referenced in "fkeys" CONTEXT: SQL statement "delete from fkeys2 where fkey21 = $1 and fkey22 = $2 " update pkeys set pkey1 = 7, pkey2 = '70' where pkey1 = 10 and pkey2 = '1'; NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys are deleted NOTICE: check_pkeys_fkey_cascade: 1 tuple(s) of fkeys2 are deleted DROP TABLE pkeys; DROP TABLE fkeys; DROP TABLE fkeys2; -- -- I've disabled the funny_dup17 test because the new semantics -- -- of AFTER ROW triggers, which get now fired at the end of a -- -- query always, cause funny_dup17 to enter an endless loop. -- -- -- -- Jan -- -- create table dup17 (x int4); -- -- create trigger dup17_before -- before insert on dup17 -- for each row -- execute procedure -- funny_dup17 () -- ; -- -- insert into dup17 values (17); -- select count(*) from dup17; -- insert into dup17 values (17); -- select count(*) from dup17; -- -- drop trigger dup17_before on dup17; -- -- create trigger dup17_after -- after insert on dup17 -- for each row -- execute procedure -- funny_dup17 () -- ; -- insert into dup17 values (13); -- select count(*) from dup17 where x = 13; -- insert into dup17 values (13); -- select count(*) from dup17 where x = 13; -- -- DROP TABLE dup17; create sequence ttdummy_seq increment 10 start 0 minvalue 0; create table tttest ( price_id int4, price_val int4, price_on int4, price_off int4 default 999999 ); create trigger ttdummy before delete or update on tttest for each row execute procedure ttdummy (price_on, price_off); create trigger ttserial before insert or update on tttest for each row execute procedure autoinc (price_on, ttdummy_seq); insert into tttest values (1, 1, null); insert into tttest values (2, 2, null); insert into tttest values (3, 3, 0); select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 2 | 2 | 20 | 999999 3 | 3 | 30 | 999999 (3 rows) delete from tttest where price_id = 2; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 3 | 3 | 30 | 999999 2 | 2 | 20 | 40 (3 rows) -- what do we see ? -- get current prices select * from tttest where price_off = 999999; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 3 | 3 | 30 | 999999 (2 rows) -- change price for price_id == 3 update tttest set price_val = 30 where price_id = 3; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 2 | 2 | 20 | 40 3 | 30 | 50 | 999999 3 | 3 | 30 | 50 (4 rows) -- now we want to change pric_id in ALL tuples -- this gets us not what we need update tttest set price_id = 5 where price_id = 3; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 2 | 2 | 20 | 40 3 | 3 | 30 | 50 5 | 30 | 60 | 999999 3 | 30 | 50 | 60 (5 rows) -- restore data as before last update: select set_ttdummy(0); set_ttdummy ------------- 1 (1 row) delete from tttest where price_id = 5; update tttest set price_off = 999999 where price_val = 30; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 2 | 2 | 20 | 40 3 | 3 | 30 | 50 3 | 30 | 50 | 999999 (4 rows) -- and try change price_id now! update tttest set price_id = 5 where price_id = 3; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 1 | 1 | 10 | 999999 2 | 2 | 20 | 40 5 | 3 | 30 | 50 5 | 30 | 50 | 999999 (4 rows) -- isn't it what we need ? select set_ttdummy(1); set_ttdummy ------------- 0 (1 row) -- we want to correct some "date" update tttest set price_on = -1 where price_id = 1; ERROR: ttdummy (tttest): you cannot change price_on and/or price_off columns (use set_ttdummy) -- but this doesn't work -- try in this way select set_ttdummy(0); set_ttdummy ------------- 1 (1 row) update tttest set price_on = -1 where price_id = 1; select * from tttest; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 2 | 2 | 20 | 40 5 | 3 | 30 | 50 5 | 30 | 50 | 999999 1 | 1 | -1 | 999999 (4 rows) -- isn't it what we need ? -- get price for price_id == 5 as it was @ "date" 35 select * from tttest where price_on <= 35 and price_off > 35 and price_id = 5; price_id | price_val | price_on | price_off ----------+-----------+----------+----------- 5 | 3 | 30 | 50 (1 row) drop table tttest; drop sequence ttdummy_seq; -- -- tests for per-statement triggers -- CREATE TABLE log_table (tstamp timestamp default timeofday()::timestamp); CREATE TABLE main_table (a int unique, b int); COPY main_table (a,b) FROM stdin; CREATE FUNCTION trigger_func() RETURNS trigger LANGUAGE plpgsql AS ' BEGIN RAISE NOTICE ''trigger_func(%) called: action = %, when = %, level = %'', TG_ARGV[0], TG_OP, TG_WHEN, TG_LEVEL; RETURN NULL; END;'; CREATE TRIGGER before_ins_stmt_trig BEFORE INSERT ON main_table FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func('before_ins_stmt'); CREATE TRIGGER after_ins_stmt_trig AFTER INSERT ON main_table FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func('after_ins_stmt'); -- -- if neither 'FOR EACH ROW' nor 'FOR EACH STATEMENT' was specified, -- CREATE TRIGGER should default to 'FOR EACH STATEMENT' -- CREATE TRIGGER after_upd_stmt_trig AFTER UPDATE ON main_table EXECUTE PROCEDURE trigger_func('after_upd_stmt'); -- Both insert and update statement level triggers (before and after) should -- fire. Doesn't fire UPDATE before trigger, but only because one isn't -- defined. INSERT INTO main_table (a, b) VALUES (5, 10) ON CONFLICT (a) DO UPDATE SET b = EXCLUDED.b; NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT CREATE TRIGGER after_upd_row_trig AFTER UPDATE ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('after_upd_row'); INSERT INTO main_table DEFAULT VALUES; NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT UPDATE main_table SET a = a + 1 WHERE b < 30; NOTICE: trigger_func(after_upd_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT -- UPDATE that effects zero rows should still call per-statement trigger UPDATE main_table SET a = a + 2 WHERE b > 100; NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT -- constraint now unneeded ALTER TABLE main_table DROP CONSTRAINT main_table_a_key; -- COPY should fire per-row and per-statement INSERT triggers COPY main_table (a, b) FROM stdin; NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT SELECT * FROM main_table ORDER BY a, b; a | b ----+---- 6 | 10 21 | 20 30 | 40 31 | 10 50 | 35 50 | 60 81 | 15 | (8 rows) -- -- test triggers with WHEN clause -- CREATE TRIGGER modified_a BEFORE UPDATE OF a ON main_table FOR EACH ROW WHEN (OLD.a <> NEW.a) EXECUTE PROCEDURE trigger_func('modified_a'); CREATE TRIGGER modified_any BEFORE UPDATE OF a ON main_table FOR EACH ROW WHEN (OLD.* IS DISTINCT FROM NEW.*) EXECUTE PROCEDURE trigger_func('modified_any'); CREATE TRIGGER insert_a AFTER INSERT ON main_table FOR EACH ROW WHEN (NEW.a = 123) EXECUTE PROCEDURE trigger_func('insert_a'); CREATE TRIGGER delete_a AFTER DELETE ON main_table FOR EACH ROW WHEN (OLD.a = 123) EXECUTE PROCEDURE trigger_func('delete_a'); CREATE TRIGGER insert_when BEFORE INSERT ON main_table FOR EACH STATEMENT WHEN (true) EXECUTE PROCEDURE trigger_func('insert_when'); CREATE TRIGGER delete_when AFTER DELETE ON main_table FOR EACH STATEMENT WHEN (true) EXECUTE PROCEDURE trigger_func('delete_when'); INSERT INTO main_table (a) VALUES (123), (456); NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(insert_when) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(insert_a) called: action = INSERT, when = AFTER, level = ROW NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT COPY main_table FROM stdin; NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(insert_when) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(insert_a) called: action = INSERT, when = AFTER, level = ROW NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT DELETE FROM main_table WHERE a IN (123, 456); NOTICE: trigger_func(delete_a) called: action = DELETE, when = AFTER, level = ROW NOTICE: trigger_func(delete_a) called: action = DELETE, when = AFTER, level = ROW NOTICE: trigger_func(delete_when) called: action = DELETE, when = AFTER, level = STATEMENT UPDATE main_table SET a = 50, b = 60; NOTICE: trigger_func(modified_any) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_any) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_a) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_a) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_a) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_a) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(modified_a) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(after_upd_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT SELECT * FROM main_table ORDER BY a, b; a | b ----+---- 6 | 10 21 | 20 30 | 40 31 | 10 50 | 35 50 | 60 81 | 15 | (8 rows) SELECT pg_get_triggerdef(oid, true) FROM pg_trigger WHERE tgrelid = 'main_table'::regclass AND tgname = 'modified_a'; pg_get_triggerdef -------------------------------------------------------------------------------------------------------------------------------------------- CREATE TRIGGER modified_a BEFORE UPDATE OF a ON main_table FOR EACH ROW WHEN (old.a <> new.a) EXECUTE PROCEDURE trigger_func('modified_a') (1 row) SELECT pg_get_triggerdef(oid, false) FROM pg_trigger WHERE tgrelid = 'main_table'::regclass AND tgname = 'modified_a'; pg_get_triggerdef ---------------------------------------------------------------------------------------------------------------------------------------------- CREATE TRIGGER modified_a BEFORE UPDATE OF a ON main_table FOR EACH ROW WHEN ((old.a <> new.a)) EXECUTE PROCEDURE trigger_func('modified_a') (1 row) SELECT pg_get_triggerdef(oid, true) FROM pg_trigger WHERE tgrelid = 'main_table'::regclass AND tgname = 'modified_any'; pg_get_triggerdef -------------------------------------------------------------------------------------------------------------------------------------------------------------- CREATE TRIGGER modified_any BEFORE UPDATE OF a ON main_table FOR EACH ROW WHEN (old.* IS DISTINCT FROM new.*) EXECUTE PROCEDURE trigger_func('modified_any') (1 row) DROP TRIGGER modified_a ON main_table; DROP TRIGGER modified_any ON main_table; DROP TRIGGER insert_a ON main_table; DROP TRIGGER delete_a ON main_table; DROP TRIGGER insert_when ON main_table; DROP TRIGGER delete_when ON main_table; -- Test column-level triggers DROP TRIGGER after_upd_row_trig ON main_table; CREATE TRIGGER before_upd_a_row_trig BEFORE UPDATE OF a ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_upd_a_row'); CREATE TRIGGER after_upd_b_row_trig AFTER UPDATE OF b ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('after_upd_b_row'); CREATE TRIGGER after_upd_a_b_row_trig AFTER UPDATE OF a, b ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('after_upd_a_b_row'); CREATE TRIGGER before_upd_a_stmt_trig BEFORE UPDATE OF a ON main_table FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func('before_upd_a_stmt'); CREATE TRIGGER after_upd_b_stmt_trig AFTER UPDATE OF b ON main_table FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func('after_upd_b_stmt'); SELECT pg_get_triggerdef(oid) FROM pg_trigger WHERE tgrelid = 'main_table'::regclass AND tgname = 'after_upd_a_b_row_trig'; pg_get_triggerdef ------------------------------------------------------------------------------------------------------------------------------------------- CREATE TRIGGER after_upd_a_b_row_trig AFTER UPDATE OF a, b ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('after_upd_a_b_row') (1 row) UPDATE main_table SET a = 50; NOTICE: trigger_func(before_upd_a_stmt) called: action = UPDATE, when = BEFORE, level = STATEMENT NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT UPDATE main_table SET b = 10; NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT -- -- Test case for bug with BEFORE trigger followed by AFTER trigger with WHEN -- CREATE TABLE some_t (some_col boolean NOT NULL); CREATE FUNCTION dummy_update_func() RETURNS trigger AS $$ BEGIN RAISE NOTICE 'dummy_update_func(%) called: action = %, old = %, new = %', TG_ARGV[0], TG_OP, OLD, NEW; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER some_trig_before BEFORE UPDATE ON some_t FOR EACH ROW EXECUTE PROCEDURE dummy_update_func('before'); CREATE TRIGGER some_trig_aftera AFTER UPDATE ON some_t FOR EACH ROW WHEN (NOT OLD.some_col AND NEW.some_col) EXECUTE PROCEDURE dummy_update_func('aftera'); CREATE TRIGGER some_trig_afterb AFTER UPDATE ON some_t FOR EACH ROW WHEN (NOT NEW.some_col) EXECUTE PROCEDURE dummy_update_func('afterb'); INSERT INTO some_t VALUES (TRUE); UPDATE some_t SET some_col = TRUE; NOTICE: dummy_update_func(before) called: action = UPDATE, old = (t), new = (t) UPDATE some_t SET some_col = FALSE; NOTICE: dummy_update_func(before) called: action = UPDATE, old = (t), new = (f) NOTICE: dummy_update_func(afterb) called: action = UPDATE, old = (t), new = (f) UPDATE some_t SET some_col = TRUE; NOTICE: dummy_update_func(before) called: action = UPDATE, old = (f), new = (t) NOTICE: dummy_update_func(aftera) called: action = UPDATE, old = (f), new = (t) DROP TABLE some_t; -- bogus cases CREATE TRIGGER error_upd_and_col BEFORE UPDATE OR UPDATE OF a ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('error_upd_and_col'); ERROR: duplicate trigger events specified at or near "ON" LINE 1: ...ER error_upd_and_col BEFORE UPDATE OR UPDATE OF a ON main_ta... ^ CREATE TRIGGER error_upd_a_a BEFORE UPDATE OF a, a ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('error_upd_a_a'); ERROR: column "a" specified more than once CREATE TRIGGER error_ins_a BEFORE INSERT OF a ON main_table FOR EACH ROW EXECUTE PROCEDURE trigger_func('error_ins_a'); ERROR: syntax error at or near "OF" LINE 1: CREATE TRIGGER error_ins_a BEFORE INSERT OF a ON main_table ^ CREATE TRIGGER error_ins_when BEFORE INSERT OR UPDATE ON main_table FOR EACH ROW WHEN (OLD.a <> NEW.a) EXECUTE PROCEDURE trigger_func('error_ins_old'); ERROR: INSERT trigger's WHEN condition cannot reference OLD values LINE 2: FOR EACH ROW WHEN (OLD.a <> NEW.a) ^ CREATE TRIGGER error_del_when BEFORE DELETE OR UPDATE ON main_table FOR EACH ROW WHEN (OLD.a <> NEW.a) EXECUTE PROCEDURE trigger_func('error_del_new'); ERROR: DELETE trigger's WHEN condition cannot reference NEW values LINE 2: FOR EACH ROW WHEN (OLD.a <> NEW.a) ^ CREATE TRIGGER error_del_when BEFORE INSERT OR UPDATE ON main_table FOR EACH ROW WHEN (NEW.tableoid <> 0) EXECUTE PROCEDURE trigger_func('error_when_sys_column'); ERROR: BEFORE trigger's WHEN condition cannot reference NEW system columns LINE 2: FOR EACH ROW WHEN (NEW.tableoid <> 0) ^ CREATE TRIGGER error_stmt_when BEFORE UPDATE OF a ON main_table FOR EACH STATEMENT WHEN (OLD.* IS DISTINCT FROM NEW.*) EXECUTE PROCEDURE trigger_func('error_stmt_when'); ERROR: statement trigger's WHEN condition cannot reference column values LINE 2: FOR EACH STATEMENT WHEN (OLD.* IS DISTINCT FROM NEW.*) ^ -- check dependency restrictions ALTER TABLE main_table DROP COLUMN b; ERROR: cannot drop table main_table column b because other objects depend on it DETAIL: trigger after_upd_b_row_trig on table main_table depends on table main_table column b trigger after_upd_a_b_row_trig on table main_table depends on table main_table column b trigger after_upd_b_stmt_trig on table main_table depends on table main_table column b HINT: Use DROP ... CASCADE to drop the dependent objects too. -- this should succeed, but we'll roll it back to keep the triggers around begin; DROP TRIGGER after_upd_a_b_row_trig ON main_table; DROP TRIGGER after_upd_b_row_trig ON main_table; DROP TRIGGER after_upd_b_stmt_trig ON main_table; ALTER TABLE main_table DROP COLUMN b; rollback; -- Test enable/disable triggers create table trigtest (i serial primary key); -- test that disabling RI triggers works create table trigtest2 (i int references trigtest(i) on delete cascade); create function trigtest() returns trigger as $$ begin raise notice '% % % %', TG_RELNAME, TG_OP, TG_WHEN, TG_LEVEL; return new; end;$$ language plpgsql; create trigger trigtest_b_row_tg before insert or update or delete on trigtest for each row execute procedure trigtest(); create trigger trigtest_a_row_tg after insert or update or delete on trigtest for each row execute procedure trigtest(); create trigger trigtest_b_stmt_tg before insert or update or delete on trigtest for each statement execute procedure trigtest(); create trigger trigtest_a_stmt_tg after insert or update or delete on trigtest for each statement execute procedure trigtest(); insert into trigtest default values; NOTICE: trigtest INSERT BEFORE STATEMENT NOTICE: trigtest INSERT BEFORE ROW NOTICE: trigtest INSERT AFTER ROW NOTICE: trigtest INSERT AFTER STATEMENT alter table trigtest disable trigger trigtest_b_row_tg; insert into trigtest default values; NOTICE: trigtest INSERT BEFORE STATEMENT NOTICE: trigtest INSERT AFTER ROW NOTICE: trigtest INSERT AFTER STATEMENT alter table trigtest disable trigger user; insert into trigtest default values; alter table trigtest enable trigger trigtest_a_stmt_tg; insert into trigtest default values; NOTICE: trigtest INSERT AFTER STATEMENT insert into trigtest2 values(1); insert into trigtest2 values(2); delete from trigtest where i=2; NOTICE: trigtest DELETE AFTER STATEMENT select * from trigtest2; i --- 1 (1 row) alter table trigtest disable trigger all; delete from trigtest where i=1; select * from trigtest2; i --- 1 (1 row) -- ensure we still insert, even when all triggers are disabled insert into trigtest default values; select * from trigtest; i --- 3 4 5 (3 rows) drop table trigtest2; drop table trigtest; -- dump trigger data CREATE TABLE trigger_test ( i int, v varchar ); CREATE OR REPLACE FUNCTION trigger_data() RETURNS trigger LANGUAGE plpgsql AS $$ declare argstr text; relid text; begin relid := TG_relid::regclass; -- plpgsql can't discover its trigger data in a hash like perl and python -- can, or by a sort of reflection like tcl can, -- so we have to hard code the names. raise NOTICE 'TG_NAME: %', TG_name; raise NOTICE 'TG_WHEN: %', TG_when; raise NOTICE 'TG_LEVEL: %', TG_level; raise NOTICE 'TG_OP: %', TG_op; raise NOTICE 'TG_RELID::regclass: %', relid; raise NOTICE 'TG_RELNAME: %', TG_relname; raise NOTICE 'TG_TABLE_NAME: %', TG_table_name; raise NOTICE 'TG_TABLE_SCHEMA: %', TG_table_schema; raise NOTICE 'TG_NARGS: %', TG_nargs; argstr := '['; for i in 0 .. TG_nargs - 1 loop if i > 0 then argstr := argstr || ', '; end if; argstr := argstr || TG_argv[i]; end loop; argstr := argstr || ']'; raise NOTICE 'TG_ARGV: %', argstr; if TG_OP != 'INSERT' then raise NOTICE 'OLD: %', OLD; end if; if TG_OP != 'DELETE' then raise NOTICE 'NEW: %', NEW; end if; if TG_OP = 'DELETE' then return OLD; else return NEW; end if; end; $$; CREATE TRIGGER show_trigger_data_trig BEFORE INSERT OR UPDATE OR DELETE ON trigger_test FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo'); insert into trigger_test values(1,'insert'); NOTICE: TG_NAME: show_trigger_data_trig NOTICE: TG_WHEN: BEFORE NOTICE: TG_LEVEL: ROW NOTICE: TG_OP: INSERT NOTICE: TG_RELID::regclass: trigger_test NOTICE: TG_RELNAME: trigger_test NOTICE: TG_TABLE_NAME: trigger_test NOTICE: TG_TABLE_SCHEMA: public NOTICE: TG_NARGS: 2 NOTICE: TG_ARGV: [23, skidoo] NOTICE: NEW: (1,insert) update trigger_test set v = 'update' where i = 1; NOTICE: TG_NAME: show_trigger_data_trig NOTICE: TG_WHEN: BEFORE NOTICE: TG_LEVEL: ROW NOTICE: TG_OP: UPDATE NOTICE: TG_RELID::regclass: trigger_test NOTICE: TG_RELNAME: trigger_test NOTICE: TG_TABLE_NAME: trigger_test NOTICE: TG_TABLE_SCHEMA: public NOTICE: TG_NARGS: 2 NOTICE: TG_ARGV: [23, skidoo] NOTICE: OLD: (1,insert) NOTICE: NEW: (1,update) delete from trigger_test; NOTICE: TG_NAME: show_trigger_data_trig NOTICE: TG_WHEN: BEFORE NOTICE: TG_LEVEL: ROW NOTICE: TG_OP: DELETE NOTICE: TG_RELID::regclass: trigger_test NOTICE: TG_RELNAME: trigger_test NOTICE: TG_TABLE_NAME: trigger_test NOTICE: TG_TABLE_SCHEMA: public NOTICE: TG_NARGS: 2 NOTICE: TG_ARGV: [23, skidoo] NOTICE: OLD: (1,update) DROP TRIGGER show_trigger_data_trig on trigger_test; DROP FUNCTION trigger_data(); DROP TABLE trigger_test; -- -- Test use of row comparisons on OLD/NEW -- CREATE TABLE trigger_test (f1 int, f2 text, f3 text); -- this is the obvious (and wrong...) way to compare rows CREATE FUNCTION mytrigger() RETURNS trigger LANGUAGE plpgsql as $$ begin if row(old.*) = row(new.*) then raise notice 'row % not changed', new.f1; else raise notice 'row % changed', new.f1; end if; return new; end$$; CREATE TRIGGER t BEFORE UPDATE ON trigger_test FOR EACH ROW EXECUTE PROCEDURE mytrigger(); INSERT INTO trigger_test VALUES(1, 'foo', 'bar'); INSERT INTO trigger_test VALUES(2, 'baz', 'quux'); UPDATE trigger_test SET f3 = 'bar'; NOTICE: row 1 not changed NOTICE: row 2 changed UPDATE trigger_test SET f3 = NULL; NOTICE: row 1 changed NOTICE: row 2 changed -- this demonstrates that the above isn't really working as desired: UPDATE trigger_test SET f3 = NULL; NOTICE: row 1 changed NOTICE: row 2 changed -- the right way when considering nulls is CREATE OR REPLACE FUNCTION mytrigger() RETURNS trigger LANGUAGE plpgsql as $$ begin if row(old.*) is distinct from row(new.*) then raise notice 'row % changed', new.f1; else raise notice 'row % not changed', new.f1; end if; return new; end$$; UPDATE trigger_test SET f3 = 'bar'; NOTICE: row 1 changed NOTICE: row 2 changed UPDATE trigger_test SET f3 = NULL; NOTICE: row 1 changed NOTICE: row 2 changed UPDATE trigger_test SET f3 = NULL; NOTICE: row 1 not changed NOTICE: row 2 not changed DROP TABLE trigger_test; DROP FUNCTION mytrigger(); -- Test snapshot management in serializable transactions involving triggers -- per bug report in 6bc73d4c0910042358k3d1adff3qa36f8df75198ecea@mail.gmail.com CREATE FUNCTION serializable_update_trig() RETURNS trigger LANGUAGE plpgsql AS $$ declare rec record; begin new.description = 'updated in trigger'; return new; end; $$; CREATE TABLE serializable_update_tab ( id int, filler text, description text ); CREATE TRIGGER serializable_update_trig BEFORE UPDATE ON serializable_update_tab FOR EACH ROW EXECUTE PROCEDURE serializable_update_trig(); INSERT INTO serializable_update_tab SELECT a, repeat('xyzxz', 100), 'new' FROM generate_series(1, 50) a; BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; UPDATE serializable_update_tab SET description = 'no no', id = 1 WHERE id = 1; COMMIT; SELECT description FROM serializable_update_tab WHERE id = 1; description -------------------- updated in trigger (1 row) DROP TABLE serializable_update_tab; -- minimal update trigger CREATE TABLE min_updates_test ( f1 text, f2 int, f3 int); CREATE TABLE min_updates_test_oids ( f1 text, f2 int, f3 int) WITH OIDS; INSERT INTO min_updates_test VALUES ('a',1,2),('b','2',null); INSERT INTO min_updates_test_oids VALUES ('a',1,2),('b','2',null); CREATE TRIGGER z_min_update BEFORE UPDATE ON min_updates_test FOR EACH ROW EXECUTE PROCEDURE suppress_redundant_updates_trigger(); CREATE TRIGGER z_min_update BEFORE UPDATE ON min_updates_test_oids FOR EACH ROW EXECUTE PROCEDURE suppress_redundant_updates_trigger(); \set QUIET false UPDATE min_updates_test SET f1 = f1; UPDATE 0 UPDATE min_updates_test SET f2 = f2 + 1; UPDATE 2 UPDATE min_updates_test SET f3 = 2 WHERE f3 is null; UPDATE 1 UPDATE min_updates_test_oids SET f1 = f1; UPDATE 0 UPDATE min_updates_test_oids SET f2 = f2 + 1; UPDATE 2 UPDATE min_updates_test_oids SET f3 = 2 WHERE f3 is null; UPDATE 1 \set QUIET true SELECT * FROM min_updates_test; f1 | f2 | f3 ----+----+---- a | 2 | 2 b | 3 | 2 (2 rows) SELECT * FROM min_updates_test_oids; f1 | f2 | f3 ----+----+---- a | 2 | 2 b | 3 | 2 (2 rows) DROP TABLE min_updates_test; DROP TABLE min_updates_test_oids; -- -- Test triggers on views -- CREATE VIEW main_view AS SELECT a, b FROM main_table; -- VIEW trigger function CREATE OR REPLACE FUNCTION view_trigger() RETURNS trigger LANGUAGE plpgsql AS $$ declare argstr text := ''; begin for i in 0 .. TG_nargs - 1 loop if i > 0 then argstr := argstr || ', '; end if; argstr := argstr || TG_argv[i]; end loop; raise notice '% % % % (%)', TG_RELNAME, TG_WHEN, TG_OP, TG_LEVEL, argstr; if TG_LEVEL = 'ROW' then if TG_OP = 'INSERT' then raise NOTICE 'NEW: %', NEW; INSERT INTO main_table VALUES (NEW.a, NEW.b); RETURN NEW; end if; if TG_OP = 'UPDATE' then raise NOTICE 'OLD: %, NEW: %', OLD, NEW; UPDATE main_table SET a = NEW.a, b = NEW.b WHERE a = OLD.a AND b = OLD.b; if NOT FOUND then RETURN NULL; end if; RETURN NEW; end if; if TG_OP = 'DELETE' then raise NOTICE 'OLD: %', OLD; DELETE FROM main_table WHERE a = OLD.a AND b = OLD.b; if NOT FOUND then RETURN NULL; end if; RETURN OLD; end if; end if; RETURN NULL; end; $$; -- Before row triggers aren't allowed on views CREATE TRIGGER invalid_trig BEFORE INSERT ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_ins_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. CREATE TRIGGER invalid_trig BEFORE UPDATE ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_upd_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. CREATE TRIGGER invalid_trig BEFORE DELETE ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_del_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. -- After row triggers aren't allowed on views CREATE TRIGGER invalid_trig AFTER INSERT ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_ins_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. CREATE TRIGGER invalid_trig AFTER UPDATE ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_upd_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. CREATE TRIGGER invalid_trig AFTER DELETE ON main_view FOR EACH ROW EXECUTE PROCEDURE trigger_func('before_del_row'); ERROR: "main_view" is a view DETAIL: Views cannot have row-level BEFORE or AFTER triggers. -- Truncate triggers aren't allowed on views CREATE TRIGGER invalid_trig BEFORE TRUNCATE ON main_view EXECUTE PROCEDURE trigger_func('before_tru_row'); ERROR: "main_view" is a view DETAIL: Views cannot have TRUNCATE triggers. CREATE TRIGGER invalid_trig AFTER TRUNCATE ON main_view EXECUTE PROCEDURE trigger_func('before_tru_row'); ERROR: "main_view" is a view DETAIL: Views cannot have TRUNCATE triggers. -- INSTEAD OF triggers aren't allowed on tables CREATE TRIGGER invalid_trig INSTEAD OF INSERT ON main_table FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_ins'); ERROR: "main_table" is a table DETAIL: Tables cannot have INSTEAD OF triggers. CREATE TRIGGER invalid_trig INSTEAD OF UPDATE ON main_table FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_upd'); ERROR: "main_table" is a table DETAIL: Tables cannot have INSTEAD OF triggers. CREATE TRIGGER invalid_trig INSTEAD OF DELETE ON main_table FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_del'); ERROR: "main_table" is a table DETAIL: Tables cannot have INSTEAD OF triggers. -- Don't support WHEN clauses with INSTEAD OF triggers CREATE TRIGGER invalid_trig INSTEAD OF UPDATE ON main_view FOR EACH ROW WHEN (OLD.a <> NEW.a) EXECUTE PROCEDURE view_trigger('instead_of_upd'); ERROR: INSTEAD OF triggers cannot have WHEN conditions -- Don't support column-level INSTEAD OF triggers CREATE TRIGGER invalid_trig INSTEAD OF UPDATE OF a ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_upd'); ERROR: INSTEAD OF triggers cannot have column lists -- Don't support statement-level INSTEAD OF triggers CREATE TRIGGER invalid_trig INSTEAD OF UPDATE ON main_view EXECUTE PROCEDURE view_trigger('instead_of_upd'); ERROR: INSTEAD OF triggers must be FOR EACH ROW -- Valid INSTEAD OF triggers CREATE TRIGGER instead_of_insert_trig INSTEAD OF INSERT ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_ins'); CREATE TRIGGER instead_of_update_trig INSTEAD OF UPDATE ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_upd'); CREATE TRIGGER instead_of_delete_trig INSTEAD OF DELETE ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_del'); -- Valid BEFORE statement VIEW triggers CREATE TRIGGER before_ins_stmt_trig BEFORE INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_ins_stmt'); CREATE TRIGGER before_upd_stmt_trig BEFORE UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_upd_stmt'); CREATE TRIGGER before_del_stmt_trig BEFORE DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_del_stmt'); -- Valid AFTER statement VIEW triggers CREATE TRIGGER after_ins_stmt_trig AFTER INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_ins_stmt'); CREATE TRIGGER after_upd_stmt_trig AFTER UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_upd_stmt'); CREATE TRIGGER after_del_stmt_trig AFTER DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_del_stmt'); \set QUIET false -- Insert into view using trigger INSERT INTO main_view VALUES (20, 30); NOTICE: main_view BEFORE INSERT STATEMENT (before_view_ins_stmt) NOTICE: main_view INSTEAD OF INSERT ROW (instead_of_ins) NOTICE: NEW: (20,30) NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT NOTICE: main_view AFTER INSERT STATEMENT (after_view_ins_stmt) INSERT 0 1 INSERT INTO main_view VALUES (21, 31) RETURNING a, b; NOTICE: main_view BEFORE INSERT STATEMENT (before_view_ins_stmt) NOTICE: main_view INSTEAD OF INSERT ROW (instead_of_ins) NOTICE: NEW: (21,31) NOTICE: trigger_func(before_ins_stmt) called: action = INSERT, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_ins_stmt) called: action = INSERT, when = AFTER, level = STATEMENT NOTICE: main_view AFTER INSERT STATEMENT (after_view_ins_stmt) a | b ----+---- 21 | 31 (1 row) INSERT 0 1 -- Table trigger will prevent updates UPDATE main_view SET b = 31 WHERE a = 20; NOTICE: main_view BEFORE UPDATE STATEMENT (before_view_upd_stmt) NOTICE: main_view INSTEAD OF UPDATE ROW (instead_of_upd) NOTICE: OLD: (20,30), NEW: (20,31) NOTICE: trigger_func(before_upd_a_stmt) called: action = UPDATE, when = BEFORE, level = STATEMENT NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(after_upd_b_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: main_view AFTER UPDATE STATEMENT (after_view_upd_stmt) UPDATE 0 UPDATE main_view SET b = 32 WHERE a = 21 AND b = 31 RETURNING a, b; NOTICE: main_view BEFORE UPDATE STATEMENT (before_view_upd_stmt) NOTICE: main_view INSTEAD OF UPDATE ROW (instead_of_upd) NOTICE: OLD: (21,31), NEW: (21,32) NOTICE: trigger_func(before_upd_a_stmt) called: action = UPDATE, when = BEFORE, level = STATEMENT NOTICE: trigger_func(before_upd_a_row) called: action = UPDATE, when = BEFORE, level = ROW NOTICE: trigger_func(after_upd_b_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: main_view AFTER UPDATE STATEMENT (after_view_upd_stmt) a | b ---+--- (0 rows) UPDATE 0 -- Remove table trigger to allow updates DROP TRIGGER before_upd_a_row_trig ON main_table; DROP TRIGGER UPDATE main_view SET b = 31 WHERE a = 20; NOTICE: main_view BEFORE UPDATE STATEMENT (before_view_upd_stmt) NOTICE: main_view INSTEAD OF UPDATE ROW (instead_of_upd) NOTICE: OLD: (20,30), NEW: (20,31) NOTICE: trigger_func(before_upd_a_stmt) called: action = UPDATE, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: main_view AFTER UPDATE STATEMENT (after_view_upd_stmt) UPDATE 1 UPDATE main_view SET b = 32 WHERE a = 21 AND b = 31 RETURNING a, b; NOTICE: main_view BEFORE UPDATE STATEMENT (before_view_upd_stmt) NOTICE: main_view INSTEAD OF UPDATE ROW (instead_of_upd) NOTICE: OLD: (21,31), NEW: (21,32) NOTICE: trigger_func(before_upd_a_stmt) called: action = UPDATE, when = BEFORE, level = STATEMENT NOTICE: trigger_func(after_upd_a_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_row) called: action = UPDATE, when = AFTER, level = ROW NOTICE: trigger_func(after_upd_b_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: trigger_func(after_upd_stmt) called: action = UPDATE, when = AFTER, level = STATEMENT NOTICE: main_view AFTER UPDATE STATEMENT (after_view_upd_stmt) a | b ----+---- 21 | 32 (1 row) UPDATE 1 -- Before and after stmt triggers should fire even when no rows are affected UPDATE main_view SET b = 0 WHERE false; NOTICE: main_view BEFORE UPDATE STATEMENT (before_view_upd_stmt) NOTICE: main_view AFTER UPDATE STATEMENT (after_view_upd_stmt) UPDATE 0 -- Delete from view using trigger DELETE FROM main_view WHERE a IN (20,21); NOTICE: main_view BEFORE DELETE STATEMENT (before_view_del_stmt) NOTICE: main_view INSTEAD OF DELETE ROW (instead_of_del) NOTICE: OLD: (21,10) NOTICE: main_view INSTEAD OF DELETE ROW (instead_of_del) NOTICE: OLD: (20,31) NOTICE: main_view INSTEAD OF DELETE ROW (instead_of_del) NOTICE: OLD: (21,32) NOTICE: main_view AFTER DELETE STATEMENT (after_view_del_stmt) DELETE 3 DELETE FROM main_view WHERE a = 31 RETURNING a, b; NOTICE: main_view BEFORE DELETE STATEMENT (before_view_del_stmt) NOTICE: main_view INSTEAD OF DELETE ROW (instead_of_del) NOTICE: OLD: (31,10) NOTICE: main_view AFTER DELETE STATEMENT (after_view_del_stmt) a | b ----+---- 31 | 10 (1 row) DELETE 1 \set QUIET true -- Describe view should list triggers \d main_view View "public.main_view" Column | Type | Collation | Nullable | Default --------+---------+-----------+----------+--------- a | integer | | | b | integer | | | Triggers: after_del_stmt_trig AFTER DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_del_stmt') after_ins_stmt_trig AFTER INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_ins_stmt') after_upd_stmt_trig AFTER UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_upd_stmt') before_del_stmt_trig BEFORE DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_del_stmt') before_ins_stmt_trig BEFORE INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_ins_stmt') before_upd_stmt_trig BEFORE UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_upd_stmt') instead_of_delete_trig INSTEAD OF DELETE ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_del') instead_of_insert_trig INSTEAD OF INSERT ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_ins') instead_of_update_trig INSTEAD OF UPDATE ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_upd') -- Test dropping view triggers DROP TRIGGER instead_of_insert_trig ON main_view; DROP TRIGGER instead_of_delete_trig ON main_view; \d+ main_view View "public.main_view" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- a | integer | | | | plain | b | integer | | | | plain | View definition: SELECT main_table.a, main_table.b FROM main_table; Triggers: after_del_stmt_trig AFTER DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_del_stmt') after_ins_stmt_trig AFTER INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_ins_stmt') after_upd_stmt_trig AFTER UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_upd_stmt') before_del_stmt_trig BEFORE DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_del_stmt') before_ins_stmt_trig BEFORE INSERT ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_ins_stmt') before_upd_stmt_trig BEFORE UPDATE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('before_view_upd_stmt') instead_of_update_trig INSTEAD OF UPDATE ON main_view FOR EACH ROW EXECUTE PROCEDURE view_trigger('instead_of_upd') DROP VIEW main_view; -- -- Test triggers on a join view -- CREATE TABLE country_table ( country_id serial primary key, country_name text unique not null, continent text not null ); INSERT INTO country_table (country_name, continent) VALUES ('Japan', 'Asia'), ('UK', 'Europe'), ('USA', 'North America') RETURNING *; country_id | country_name | continent ------------+--------------+--------------- 1 | Japan | Asia 2 | UK | Europe 3 | USA | North America (3 rows) CREATE TABLE city_table ( city_id serial primary key, city_name text not null, population bigint, country_id int references country_table ); CREATE VIEW city_view AS SELECT city_id, city_name, population, country_name, continent FROM city_table ci LEFT JOIN country_table co ON co.country_id = ci.country_id; CREATE FUNCTION city_insert() RETURNS trigger LANGUAGE plpgsql AS $$ declare ctry_id int; begin if NEW.country_name IS NOT NULL then SELECT country_id, continent INTO ctry_id, NEW.continent FROM country_table WHERE country_name = NEW.country_name; if NOT FOUND then raise exception 'No such country: "%"', NEW.country_name; end if; else NEW.continent := NULL; end if; if NEW.city_id IS NOT NULL then INSERT INTO city_table VALUES(NEW.city_id, NEW.city_name, NEW.population, ctry_id); else INSERT INTO city_table(city_name, population, country_id) VALUES(NEW.city_name, NEW.population, ctry_id) RETURNING city_id INTO NEW.city_id; end if; RETURN NEW; end; $$; CREATE TRIGGER city_insert_trig INSTEAD OF INSERT ON city_view FOR EACH ROW EXECUTE PROCEDURE city_insert(); CREATE FUNCTION city_delete() RETURNS trigger LANGUAGE plpgsql AS $$ begin DELETE FROM city_table WHERE city_id = OLD.city_id; if NOT FOUND then RETURN NULL; end if; RETURN OLD; end; $$; CREATE TRIGGER city_delete_trig INSTEAD OF DELETE ON city_view FOR EACH ROW EXECUTE PROCEDURE city_delete(); CREATE FUNCTION city_update() RETURNS trigger LANGUAGE plpgsql AS $$ declare ctry_id int; begin if NEW.country_name IS DISTINCT FROM OLD.country_name then SELECT country_id, continent INTO ctry_id, NEW.continent FROM country_table WHERE country_name = NEW.country_name; if NOT FOUND then raise exception 'No such country: "%"', NEW.country_name; end if; UPDATE city_table SET city_name = NEW.city_name, population = NEW.population, country_id = ctry_id WHERE city_id = OLD.city_id; else UPDATE city_table SET city_name = NEW.city_name, population = NEW.population WHERE city_id = OLD.city_id; NEW.continent := OLD.continent; end if; if NOT FOUND then RETURN NULL; end if; RETURN NEW; end; $$; CREATE TRIGGER city_update_trig INSTEAD OF UPDATE ON city_view FOR EACH ROW EXECUTE PROCEDURE city_update(); \set QUIET false -- INSERT .. RETURNING INSERT INTO city_view(city_name) VALUES('Tokyo') RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 1 | Tokyo | | | (1 row) INSERT 0 1 INSERT INTO city_view(city_name, population) VALUES('London', 7556900) RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 2 | London | 7556900 | | (1 row) INSERT 0 1 INSERT INTO city_view(city_name, country_name) VALUES('Washington DC', 'USA') RETURNING *; city_id | city_name | population | country_name | continent ---------+---------------+------------+--------------+--------------- 3 | Washington DC | | USA | North America (1 row) INSERT 0 1 INSERT INTO city_view(city_id, city_name) VALUES(123456, 'New York') RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 123456 | New York | | | (1 row) INSERT 0 1 INSERT INTO city_view VALUES(234567, 'Birmingham', 1016800, 'UK', 'EU') RETURNING *; city_id | city_name | population | country_name | continent ---------+------------+------------+--------------+----------- 234567 | Birmingham | 1016800 | UK | Europe (1 row) INSERT 0 1 -- UPDATE .. RETURNING UPDATE city_view SET country_name = 'Japon' WHERE city_name = 'Tokyo'; -- error ERROR: No such country: "Japon" CONTEXT: PL/pgSQL function city_update() line 9 at RAISE UPDATE city_view SET country_name = 'Japan' WHERE city_name = 'Takyo'; -- no match UPDATE 0 UPDATE city_view SET country_name = 'Japan' WHERE city_name = 'Tokyo' RETURNING *; -- OK city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 1 | Tokyo | | Japan | Asia (1 row) UPDATE 1 UPDATE city_view SET population = 13010279 WHERE city_name = 'Tokyo' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 1 | Tokyo | 13010279 | Japan | Asia (1 row) UPDATE 1 UPDATE city_view SET country_name = 'UK' WHERE city_name = 'New York' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 123456 | New York | | UK | Europe (1 row) UPDATE 1 UPDATE city_view SET country_name = 'USA', population = 8391881 WHERE city_name = 'New York' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+--------------- 123456 | New York | 8391881 | USA | North America (1 row) UPDATE 1 UPDATE city_view SET continent = 'EU' WHERE continent = 'Europe' RETURNING *; city_id | city_name | population | country_name | continent ---------+------------+------------+--------------+----------- 234567 | Birmingham | 1016800 | UK | Europe (1 row) UPDATE 1 UPDATE city_view v1 SET country_name = v2.country_name FROM city_view v2 WHERE v2.city_name = 'Birmingham' AND v1.city_name = 'London' RETURNING *; city_id | city_name | population | country_name | continent | city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+-----------+---------+------------+------------+--------------+----------- 2 | London | 7556900 | UK | Europe | 234567 | Birmingham | 1016800 | UK | Europe (1 row) UPDATE 1 -- DELETE .. RETURNING DELETE FROM city_view WHERE city_name = 'Birmingham' RETURNING *; city_id | city_name | population | country_name | continent ---------+------------+------------+--------------+----------- 234567 | Birmingham | 1016800 | UK | Europe (1 row) DELETE 1 \set QUIET true -- read-only view with WHERE clause CREATE VIEW european_city_view AS SELECT * FROM city_view WHERE continent = 'Europe'; SELECT count(*) FROM european_city_view; count ------- 1 (1 row) CREATE FUNCTION no_op_trig_fn() RETURNS trigger LANGUAGE plpgsql AS 'begin RETURN NULL; end'; CREATE TRIGGER no_op_trig INSTEAD OF INSERT OR UPDATE OR DELETE ON european_city_view FOR EACH ROW EXECUTE PROCEDURE no_op_trig_fn(); \set QUIET false INSERT INTO european_city_view VALUES (0, 'x', 10000, 'y', 'z'); INSERT 0 0 UPDATE european_city_view SET population = 10000; UPDATE 0 DELETE FROM european_city_view; DELETE 0 \set QUIET true -- rules bypassing no-op triggers CREATE RULE european_city_insert_rule AS ON INSERT TO european_city_view DO INSTEAD INSERT INTO city_view VALUES (NEW.city_id, NEW.city_name, NEW.population, NEW.country_name, NEW.continent) RETURNING *; CREATE RULE european_city_update_rule AS ON UPDATE TO european_city_view DO INSTEAD UPDATE city_view SET city_name = NEW.city_name, population = NEW.population, country_name = NEW.country_name WHERE city_id = OLD.city_id RETURNING NEW.*; CREATE RULE european_city_delete_rule AS ON DELETE TO european_city_view DO INSTEAD DELETE FROM city_view WHERE city_id = OLD.city_id RETURNING *; \set QUIET false -- INSERT not limited by view's WHERE clause, but UPDATE AND DELETE are INSERT INTO european_city_view(city_name, country_name) VALUES ('Cambridge', 'USA') RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+--------------- 4 | Cambridge | | USA | North America (1 row) INSERT 0 1 UPDATE european_city_view SET country_name = 'UK' WHERE city_name = 'Cambridge'; UPDATE 0 DELETE FROM european_city_view WHERE city_name = 'Cambridge'; DELETE 0 -- UPDATE and DELETE via rule and trigger UPDATE city_view SET country_name = 'UK' WHERE city_name = 'Cambridge' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 4 | Cambridge | | UK | Europe (1 row) UPDATE 1 UPDATE european_city_view SET population = 122800 WHERE city_name = 'Cambridge' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 4 | Cambridge | 122800 | UK | Europe (1 row) UPDATE 1 DELETE FROM european_city_view WHERE city_name = 'Cambridge' RETURNING *; city_id | city_name | population | country_name | continent ---------+-----------+------------+--------------+----------- 4 | Cambridge | 122800 | UK | Europe (1 row) DELETE 1 -- join UPDATE test UPDATE city_view v SET population = 599657 FROM city_table ci, country_table co WHERE ci.city_name = 'Washington DC' and co.country_name = 'USA' AND v.city_id = ci.city_id AND v.country_name = co.country_name RETURNING co.country_id, v.country_name, v.city_id, v.city_name, v.population; country_id | country_name | city_id | city_name | population ------------+--------------+---------+---------------+------------ 3 | USA | 3 | Washington DC | 599657 (1 row) UPDATE 1 \set QUIET true SELECT * FROM city_view; city_id | city_name | population | country_name | continent ---------+---------------+------------+--------------+--------------- 1 | Tokyo | 13010279 | Japan | Asia 123456 | New York | 8391881 | USA | North America 2 | London | 7556900 | UK | Europe 3 | Washington DC | 599657 | USA | North America (4 rows) DROP TABLE city_table CASCADE; NOTICE: drop cascades to 2 other objects DETAIL: drop cascades to view city_view drop cascades to view european_city_view DROP TABLE country_table; -- Test pg_trigger_depth() create table depth_a (id int not null primary key); create table depth_b (id int not null primary key); create table depth_c (id int not null primary key); create function depth_a_tf() returns trigger language plpgsql as $$ begin raise notice '%: depth = %', tg_name, pg_trigger_depth(); insert into depth_b values (new.id); raise notice '%: depth = %', tg_name, pg_trigger_depth(); return new; end; $$; create trigger depth_a_tr before insert on depth_a for each row execute procedure depth_a_tf(); create function depth_b_tf() returns trigger language plpgsql as $$ begin raise notice '%: depth = %', tg_name, pg_trigger_depth(); begin execute 'insert into depth_c values (' || new.id::text || ')'; exception when sqlstate 'U9999' then raise notice 'SQLSTATE = U9999: depth = %', pg_trigger_depth(); end; raise notice '%: depth = %', tg_name, pg_trigger_depth(); if new.id = 1 then execute 'insert into depth_c values (' || new.id::text || ')'; end if; return new; end; $$; create trigger depth_b_tr before insert on depth_b for each row execute procedure depth_b_tf(); create function depth_c_tf() returns trigger language plpgsql as $$ begin raise notice '%: depth = %', tg_name, pg_trigger_depth(); if new.id = 1 then raise exception sqlstate 'U9999'; end if; raise notice '%: depth = %', tg_name, pg_trigger_depth(); return new; end; $$; create trigger depth_c_tr before insert on depth_c for each row execute procedure depth_c_tf(); select pg_trigger_depth(); pg_trigger_depth ------------------ 0 (1 row) insert into depth_a values (1); NOTICE: depth_a_tr: depth = 1 NOTICE: depth_b_tr: depth = 2 NOTICE: depth_c_tr: depth = 3 NOTICE: SQLSTATE = U9999: depth = 2 NOTICE: depth_b_tr: depth = 2 NOTICE: depth_c_tr: depth = 3 ERROR: U9999 CONTEXT: PL/pgSQL function depth_c_tf() line 5 at RAISE SQL statement "insert into depth_c values (1)" PL/pgSQL function depth_b_tf() line 12 at EXECUTE SQL statement "insert into depth_b values (new.id)" PL/pgSQL function depth_a_tf() line 4 at SQL statement select pg_trigger_depth(); pg_trigger_depth ------------------ 0 (1 row) insert into depth_a values (2); NOTICE: depth_a_tr: depth = 1 NOTICE: depth_b_tr: depth = 2 NOTICE: depth_c_tr: depth = 3 NOTICE: depth_c_tr: depth = 3 NOTICE: depth_b_tr: depth = 2 NOTICE: depth_a_tr: depth = 1 select pg_trigger_depth(); pg_trigger_depth ------------------ 0 (1 row) drop table depth_a, depth_b, depth_c; drop function depth_a_tf(); drop function depth_b_tf(); drop function depth_c_tf(); -- -- Test updates to rows during firing of BEFORE ROW triggers. -- As of 9.2, such cases should be rejected (see bug #6123). -- create temp table parent ( aid int not null primary key, val1 text, val2 text, val3 text, val4 text, bcnt int not null default 0); create temp table child ( bid int not null primary key, aid int not null, val1 text); create function parent_upd_func() returns trigger language plpgsql as $$ begin if old.val1 <> new.val1 then new.val2 = new.val1; delete from child where child.aid = new.aid and child.val1 = new.val1; end if; return new; end; $$; create trigger parent_upd_trig before update on parent for each row execute procedure parent_upd_func(); create function parent_del_func() returns trigger language plpgsql as $$ begin delete from child where aid = old.aid; return old; end; $$; create trigger parent_del_trig before delete on parent for each row execute procedure parent_del_func(); create function child_ins_func() returns trigger language plpgsql as $$ begin update parent set bcnt = bcnt + 1 where aid = new.aid; return new; end; $$; create trigger child_ins_trig after insert on child for each row execute procedure child_ins_func(); create function child_del_func() returns trigger language plpgsql as $$ begin update parent set bcnt = bcnt - 1 where aid = old.aid; return old; end; $$; create trigger child_del_trig after delete on child for each row execute procedure child_del_func(); insert into parent values (1, 'a', 'a', 'a', 'a', 0); insert into child values (10, 1, 'b'); select * from parent; select * from child; aid | val1 | val2 | val3 | val4 | bcnt -----+------+------+------+------+------ 1 | a | a | a | a | 1 (1 row) bid | aid | val1 -----+-----+------ 10 | 1 | b (1 row) update parent set val1 = 'b' where aid = 1; -- should fail ERROR: tuple to be updated was already modified by an operation triggered by the current command HINT: Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows. select * from parent; select * from child; aid | val1 | val2 | val3 | val4 | bcnt -----+------+------+------+------+------ 1 | a | a | a | a | 1 (1 row) bid | aid | val1 -----+-----+------ 10 | 1 | b (1 row) delete from parent where aid = 1; -- should fail ERROR: tuple to be updated was already modified by an operation triggered by the current command HINT: Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows. select * from parent; select * from child; aid | val1 | val2 | val3 | val4 | bcnt -----+------+------+------+------+------ 1 | a | a | a | a | 1 (1 row) bid | aid | val1 -----+-----+------ 10 | 1 | b (1 row) -- replace the trigger function with one that restarts the deletion after -- having modified a child create or replace function parent_del_func() returns trigger language plpgsql as $$ begin delete from child where aid = old.aid; if found then delete from parent where aid = old.aid; return null; -- cancel outer deletion end if; return old; end; $$; delete from parent where aid = 1; select * from parent; select * from child; aid | val1 | val2 | val3 | val4 | bcnt -----+------+------+------+------+------ (0 rows) bid | aid | val1 -----+-----+------ (0 rows) drop table parent, child; drop function parent_upd_func(); drop function parent_del_func(); drop function child_ins_func(); drop function child_del_func(); -- similar case, but with a self-referencing FK so that parent and child -- rows can be affected by a single operation create temp table self_ref_trigger ( id int primary key, parent int references self_ref_trigger, data text, nchildren int not null default 0 ); create function self_ref_trigger_ins_func() returns trigger language plpgsql as $$ begin if new.parent is not null then update self_ref_trigger set nchildren = nchildren + 1 where id = new.parent; end if; return new; end; $$; create trigger self_ref_trigger_ins_trig before insert on self_ref_trigger for each row execute procedure self_ref_trigger_ins_func(); create function self_ref_trigger_del_func() returns trigger language plpgsql as $$ begin if old.parent is not null then update self_ref_trigger set nchildren = nchildren - 1 where id = old.parent; end if; return old; end; $$; create trigger self_ref_trigger_del_trig before delete on self_ref_trigger for each row execute procedure self_ref_trigger_del_func(); insert into self_ref_trigger values (1, null, 'root'); insert into self_ref_trigger values (2, 1, 'root child A'); insert into self_ref_trigger values (3, 1, 'root child B'); insert into self_ref_trigger values (4, 2, 'grandchild 1'); insert into self_ref_trigger values (5, 3, 'grandchild 2'); update self_ref_trigger set data = 'root!' where id = 1; select * from self_ref_trigger; id | parent | data | nchildren ----+--------+--------------+----------- 2 | 1 | root child A | 1 4 | 2 | grandchild 1 | 0 3 | 1 | root child B | 1 5 | 3 | grandchild 2 | 0 1 | | root! | 2 (5 rows) delete from self_ref_trigger; ERROR: tuple to be updated was already modified by an operation triggered by the current command HINT: Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows. select * from self_ref_trigger; id | parent | data | nchildren ----+--------+--------------+----------- 2 | 1 | root child A | 1 4 | 2 | grandchild 1 | 0 3 | 1 | root child B | 1 5 | 3 | grandchild 2 | 0 1 | | root! | 2 (5 rows) drop table self_ref_trigger; drop function self_ref_trigger_ins_func(); drop function self_ref_trigger_del_func(); -- -- Check that index creation (or DDL in general) is prohibited in a trigger -- create table trigger_ddl_table ( col1 integer, col2 integer ); create function trigger_ddl_func() returns trigger as $$ begin alter table trigger_ddl_table add primary key (col1); return new; end$$ language plpgsql; create trigger trigger_ddl_func before insert on trigger_ddl_table for each row execute procedure trigger_ddl_func(); insert into trigger_ddl_table values (1, 42); -- fail ERROR: cannot ALTER TABLE "trigger_ddl_table" because it is being used by active queries in this session CONTEXT: SQL statement "alter table trigger_ddl_table add primary key (col1)" PL/pgSQL function trigger_ddl_func() line 3 at SQL statement create or replace function trigger_ddl_func() returns trigger as $$ begin create index on trigger_ddl_table (col2); return new; end$$ language plpgsql; insert into trigger_ddl_table values (1, 42); -- fail ERROR: cannot CREATE INDEX "trigger_ddl_table" because it is being used by active queries in this session CONTEXT: SQL statement "create index on trigger_ddl_table (col2)" PL/pgSQL function trigger_ddl_func() line 3 at SQL statement drop table trigger_ddl_table; drop function trigger_ddl_func(); -- -- Verify behavior of before and after triggers with INSERT...ON CONFLICT -- DO UPDATE -- create table upsert (key int4 primary key, color text); create function upsert_before_func() returns trigger language plpgsql as $$ begin if (TG_OP = 'UPDATE') then raise warning 'before update (old): %', old.*::text; raise warning 'before update (new): %', new.*::text; elsif (TG_OP = 'INSERT') then raise warning 'before insert (new): %', new.*::text; if new.key % 2 = 0 then new.key := new.key + 1; new.color := new.color || ' trig modified'; raise warning 'before insert (new, modified): %', new.*::text; end if; end if; return new; end; $$; create trigger upsert_before_trig before insert or update on upsert for each row execute procedure upsert_before_func(); create function upsert_after_func() returns trigger language plpgsql as $$ begin if (TG_OP = 'UPDATE') then raise warning 'after update (old): %', old.*::text; raise warning 'after update (new): %', new.*::text; elsif (TG_OP = 'INSERT') then raise warning 'after insert (new): %', new.*::text; end if; return null; end; $$; create trigger upsert_after_trig after insert or update on upsert for each row execute procedure upsert_after_func(); insert into upsert values(1, 'black') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (1,black) WARNING: after insert (new): (1,black) insert into upsert values(2, 'red') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (2,red) WARNING: before insert (new, modified): (3,"red trig modified") WARNING: after insert (new): (3,"red trig modified") insert into upsert values(3, 'orange') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (3,orange) WARNING: before update (old): (3,"red trig modified") WARNING: before update (new): (3,"updated red trig modified") WARNING: after update (old): (3,"red trig modified") WARNING: after update (new): (3,"updated red trig modified") insert into upsert values(4, 'green') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (4,green) WARNING: before insert (new, modified): (5,"green trig modified") WARNING: after insert (new): (5,"green trig modified") insert into upsert values(5, 'purple') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (5,purple) WARNING: before update (old): (5,"green trig modified") WARNING: before update (new): (5,"updated green trig modified") WARNING: after update (old): (5,"green trig modified") WARNING: after update (new): (5,"updated green trig modified") insert into upsert values(6, 'white') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (6,white) WARNING: before insert (new, modified): (7,"white trig modified") WARNING: after insert (new): (7,"white trig modified") insert into upsert values(7, 'pink') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (7,pink) WARNING: before update (old): (7,"white trig modified") WARNING: before update (new): (7,"updated white trig modified") WARNING: after update (old): (7,"white trig modified") WARNING: after update (new): (7,"updated white trig modified") insert into upsert values(8, 'yellow') on conflict (key) do update set color = 'updated ' || upsert.color; WARNING: before insert (new): (8,yellow) WARNING: before insert (new, modified): (9,"yellow trig modified") WARNING: after insert (new): (9,"yellow trig modified") select * from upsert; key | color -----+----------------------------- 1 | black 3 | updated red trig modified 5 | updated green trig modified 7 | updated white trig modified 9 | yellow trig modified (5 rows) drop table upsert; drop function upsert_before_func(); drop function upsert_after_func(); -- -- Verify that triggers with transition tables are not allowed on -- views -- create table my_table (i int); create view my_view as select * from my_table; create function my_trigger_function() returns trigger as $$ begin end; $$ language plpgsql; create trigger my_trigger after update on my_view referencing old table as old_table for each statement execute procedure my_trigger_function(); ERROR: "my_view" is a view DETAIL: Triggers on views cannot have transition tables. drop function my_trigger_function(); drop view my_view; drop table my_table; -- -- Verify that per-statement triggers are fired for partitioned tables -- create table parted_stmt_trig (a int) partition by list (a); create table parted_stmt_trig1 partition of parted_stmt_trig for values in (1); create table parted_stmt_trig2 partition of parted_stmt_trig for values in (2); create table parted2_stmt_trig (a int) partition by list (a); create table parted2_stmt_trig1 partition of parted2_stmt_trig for values in (1); create table parted2_stmt_trig2 partition of parted2_stmt_trig for values in (2); create or replace function trigger_notice() returns trigger as $$ begin raise notice 'trigger on % % % for %', TG_TABLE_NAME, TG_WHEN, TG_OP, TG_LEVEL; if TG_LEVEL = 'ROW' then return NEW; end if; return null; end; $$ language plpgsql; -- insert/update/delete statment-level triggers on the parent create trigger trig_ins_before before insert on parted_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_ins_after after insert on parted_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_upd_before before update on parted_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_upd_after after update on parted_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_del_before before delete on parted_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_del_after after delete on parted_stmt_trig for each statement execute procedure trigger_notice(); -- insert/update/delete row-level triggers on the first partition create trigger trig_ins_before before insert on parted_stmt_trig1 for each row execute procedure trigger_notice(); create trigger trig_ins_after after insert on parted_stmt_trig1 for each row execute procedure trigger_notice(); create trigger trig_upd_before before update on parted_stmt_trig1 for each row execute procedure trigger_notice(); create trigger trig_upd_after after update on parted_stmt_trig1 for each row execute procedure trigger_notice(); -- insert/update/delete statement-level triggers on the parent create trigger trig_ins_before before insert on parted2_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_ins_after after insert on parted2_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_upd_before before update on parted2_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_upd_after after update on parted2_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_del_before before delete on parted2_stmt_trig for each statement execute procedure trigger_notice(); create trigger trig_del_after after delete on parted2_stmt_trig for each statement execute procedure trigger_notice(); with ins (a) as ( insert into parted2_stmt_trig values (1), (2) returning a ) insert into parted_stmt_trig select a from ins returning tableoid::regclass, a; NOTICE: trigger on parted_stmt_trig BEFORE INSERT for STATEMENT NOTICE: trigger on parted2_stmt_trig BEFORE INSERT for STATEMENT NOTICE: trigger on parted_stmt_trig1 BEFORE INSERT for ROW NOTICE: trigger on parted_stmt_trig1 AFTER INSERT for ROW NOTICE: trigger on parted2_stmt_trig AFTER INSERT for STATEMENT NOTICE: trigger on parted_stmt_trig AFTER INSERT for STATEMENT tableoid | a -------------------+--- parted_stmt_trig1 | 1 parted_stmt_trig2 | 2 (2 rows) with upd as ( update parted2_stmt_trig set a = a ) update parted_stmt_trig set a = a; NOTICE: trigger on parted_stmt_trig BEFORE UPDATE for STATEMENT NOTICE: trigger on parted_stmt_trig1 BEFORE UPDATE for ROW NOTICE: trigger on parted2_stmt_trig BEFORE UPDATE for STATEMENT NOTICE: trigger on parted_stmt_trig1 AFTER UPDATE for ROW NOTICE: trigger on parted_stmt_trig AFTER UPDATE for STATEMENT NOTICE: trigger on parted2_stmt_trig AFTER UPDATE for STATEMENT delete from parted_stmt_trig; NOTICE: trigger on parted_stmt_trig BEFORE DELETE for STATEMENT NOTICE: trigger on parted_stmt_trig AFTER DELETE for STATEMENT -- insert via copy on the parent copy parted_stmt_trig(a) from stdin; NOTICE: trigger on parted_stmt_trig BEFORE INSERT for STATEMENT NOTICE: trigger on parted_stmt_trig1 BEFORE INSERT for ROW NOTICE: trigger on parted_stmt_trig1 AFTER INSERT for ROW NOTICE: trigger on parted_stmt_trig AFTER INSERT for STATEMENT -- insert via copy on the first partition copy parted_stmt_trig1(a) from stdin; NOTICE: trigger on parted_stmt_trig1 BEFORE INSERT for ROW NOTICE: trigger on parted_stmt_trig1 AFTER INSERT for ROW drop table parted_stmt_trig, parted2_stmt_trig; -- -- Test the interaction between transition tables and both kinds of -- inheritance. We'll dump the contents of the transition tables in a -- format that shows the attribute order, so that we can distinguish -- tuple formats (though not dropped attributes). -- create or replace function dump_insert() returns trigger language plpgsql as $$ begin raise notice 'trigger = %, new table = %', TG_NAME, (select string_agg(new_table::text, ', ' order by a) from new_table); return null; end; $$; create or replace function dump_update() returns trigger language plpgsql as $$ begin raise notice 'trigger = %, old table = %, new table = %', TG_NAME, (select string_agg(old_table::text, ', ' order by a) from old_table), (select string_agg(new_table::text, ', ' order by a) from new_table); return null; end; $$; create or replace function dump_delete() returns trigger language plpgsql as $$ begin raise notice 'trigger = %, old table = %', TG_NAME, (select string_agg(old_table::text, ', ' order by a) from old_table); return null; end; $$; -- -- Verify behavior of statement triggers on partition hierarchy with -- transition tables. Tuples should appear to each trigger in the -- format of the the relation the trigger is attached to. -- -- set up a partition hierarchy with some different TupleDescriptors create table parent (a text, b int) partition by list (a); -- a child matching parent create table child1 partition of parent for values in ('AAA'); -- a child with a dropped column create table child2 (x int, a text, b int); alter table child2 drop column x; alter table parent attach partition child2 for values in ('BBB'); -- a child with a different column order create table child3 (b int, a text); alter table parent attach partition child3 for values in ('CCC'); create trigger parent_insert_trig after insert on parent referencing new table as new_table for each statement execute procedure dump_insert(); create trigger parent_update_trig after update on parent referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger parent_delete_trig after delete on parent referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child1_insert_trig after insert on child1 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child1_update_trig after update on child1 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child1_delete_trig after delete on child1 referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child2_insert_trig after insert on child2 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child2_update_trig after update on child2 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child2_delete_trig after delete on child2 referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child3_insert_trig after insert on child3 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child3_update_trig after update on child3 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child3_delete_trig after delete on child3 referencing old table as old_table for each statement execute procedure dump_delete(); -- insert directly into children sees respective child-format tuples insert into child1 values ('AAA', 42); NOTICE: trigger = child1_insert_trig, new table = (AAA,42) insert into child2 values ('BBB', 42); NOTICE: trigger = child2_insert_trig, new table = (BBB,42) insert into child3 values (42, 'CCC'); NOTICE: trigger = child3_insert_trig, new table = (42,CCC) -- update via parent sees parent-format tuples update parent set b = b + 1; NOTICE: trigger = parent_update_trig, old table = (AAA,42), (BBB,42), (CCC,42), new table = (AAA,43), (BBB,43), (CCC,43) -- delete via parent sees parent-format tuples delete from parent; NOTICE: trigger = parent_delete_trig, old table = (AAA,43), (BBB,43), (CCC,43) -- insert into parent sees parent-format tuples insert into parent values ('AAA', 42); NOTICE: trigger = parent_insert_trig, new table = (AAA,42) insert into parent values ('BBB', 42); NOTICE: trigger = parent_insert_trig, new table = (BBB,42) insert into parent values ('CCC', 42); NOTICE: trigger = parent_insert_trig, new table = (CCC,42) -- delete from children sees respective child-format tuples delete from child1; NOTICE: trigger = child1_delete_trig, old table = (AAA,42) delete from child2; NOTICE: trigger = child2_delete_trig, old table = (BBB,42) delete from child3; NOTICE: trigger = child3_delete_trig, old table = (42,CCC) -- copy into parent sees parent-format tuples copy parent (a, b) from stdin; NOTICE: trigger = parent_insert_trig, new table = (AAA,42), (BBB,42), (CCC,42) -- DML affecting parent sees tuples collected from children even if -- there is no transition table trigger on the children drop trigger child1_insert_trig on child1; drop trigger child1_update_trig on child1; drop trigger child1_delete_trig on child1; drop trigger child2_insert_trig on child2; drop trigger child2_update_trig on child2; drop trigger child2_delete_trig on child2; drop trigger child3_insert_trig on child3; drop trigger child3_update_trig on child3; drop trigger child3_delete_trig on child3; delete from parent; NOTICE: trigger = parent_delete_trig, old table = (AAA,42), (BBB,42), (CCC,42) -- copy into parent sees tuples collected from children even if there -- is no transition-table trigger on the children copy parent (a, b) from stdin; NOTICE: trigger = parent_insert_trig, new table = (AAA,42), (BBB,42), (CCC,42) -- insert into parent with a before trigger on a child tuple before -- insertion, and we capture the newly modified row in parent format create or replace function intercept_insert() returns trigger language plpgsql as $$ begin new.b = new.b + 1000; return new; end; $$; create trigger intercept_insert_child3 before insert on child3 for each row execute procedure intercept_insert(); -- insert, parent trigger sees post-modification parent-format tuple insert into parent values ('AAA', 42), ('BBB', 42), ('CCC', 66); NOTICE: trigger = parent_insert_trig, new table = (AAA,42), (BBB,42), (CCC,1066) -- copy, parent trigger sees post-modification parent-format tuple copy parent (a, b) from stdin; NOTICE: trigger = parent_insert_trig, new table = (AAA,42), (BBB,42), (CCC,1234) drop table child1, child2, child3, parent; drop function intercept_insert(); -- -- Verify prohibition of row triggers with transition triggers on -- partitions -- create table parent (a text, b int) partition by list (a); create table child partition of parent for values in ('AAA'); -- adding row trigger with transition table fails create trigger child_row_trig after insert on child referencing new table as new_table for each row execute procedure dump_insert(); ERROR: ROW triggers with transition tables are not supported on partitions -- detaching it first works alter table parent detach partition child; create trigger child_row_trig after insert on child referencing new table as new_table for each row execute procedure dump_insert(); -- but now we're not allowed to reattach it alter table parent attach partition child for values in ('AAA'); ERROR: trigger "child_row_trig" prevents table "child" from becoming a partition DETAIL: ROW triggers with transition tables are not supported on partitions -- drop the trigger, and now we're allowed to attach it again drop trigger child_row_trig on child; alter table parent attach partition child for values in ('AAA'); drop table child, parent; -- -- Verify behavior of statement triggers on (non-partition) -- inheritance hierarchy with transition tables; similar to the -- partition case, except there is no rerouting on insertion and child -- tables can have extra columns -- -- set up inheritance hierarchy with different TupleDescriptors create table parent (a text, b int); -- a child matching parent create table child1 () inherits (parent); -- a child with a different column order create table child2 (b int, a text); alter table child2 inherit parent; -- a child with an extra column create table child3 (c text) inherits (parent); create trigger parent_insert_trig after insert on parent referencing new table as new_table for each statement execute procedure dump_insert(); create trigger parent_update_trig after update on parent referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger parent_delete_trig after delete on parent referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child1_insert_trig after insert on child1 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child1_update_trig after update on child1 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child1_delete_trig after delete on child1 referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child2_insert_trig after insert on child2 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child2_update_trig after update on child2 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child2_delete_trig after delete on child2 referencing old table as old_table for each statement execute procedure dump_delete(); create trigger child3_insert_trig after insert on child3 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger child3_update_trig after update on child3 referencing old table as old_table new table as new_table for each statement execute procedure dump_update(); create trigger child3_delete_trig after delete on child3 referencing old table as old_table for each statement execute procedure dump_delete(); -- insert directly into children sees respective child-format tuples insert into child1 values ('AAA', 42); NOTICE: trigger = child1_insert_trig, new table = (AAA,42) insert into child2 values (42, 'BBB'); NOTICE: trigger = child2_insert_trig, new table = (42,BBB) insert into child3 values ('CCC', 42, 'foo'); NOTICE: trigger = child3_insert_trig, new table = (CCC,42,foo) -- update via parent sees parent-format tuples update parent set b = b + 1; NOTICE: trigger = parent_update_trig, old table = (AAA,42), (BBB,42), (CCC,42), new table = (AAA,43), (BBB,43), (CCC,43) -- delete via parent sees parent-format tuples delete from parent; NOTICE: trigger = parent_delete_trig, old table = (AAA,43), (BBB,43), (CCC,43) -- reinsert values into children for next test... insert into child1 values ('AAA', 42); NOTICE: trigger = child1_insert_trig, new table = (AAA,42) insert into child2 values (42, 'BBB'); NOTICE: trigger = child2_insert_trig, new table = (42,BBB) insert into child3 values ('CCC', 42, 'foo'); NOTICE: trigger = child3_insert_trig, new table = (CCC,42,foo) -- delete from children sees respective child-format tuples delete from child1; NOTICE: trigger = child1_delete_trig, old table = (AAA,42) delete from child2; NOTICE: trigger = child2_delete_trig, old table = (42,BBB) delete from child3; NOTICE: trigger = child3_delete_trig, old table = (CCC,42,foo) -- copy into parent sees parent-format tuples (no rerouting, so these -- are really inserted into the parent) copy parent (a, b) from stdin; NOTICE: trigger = parent_insert_trig, new table = (AAA,42), (BBB,42), (CCC,42) -- DML affecting parent sees tuples collected from children even if -- there is no transition table trigger on the children drop trigger child1_insert_trig on child1; drop trigger child1_update_trig on child1; drop trigger child1_delete_trig on child1; drop trigger child2_insert_trig on child2; drop trigger child2_update_trig on child2; drop trigger child2_delete_trig on child2; drop trigger child3_insert_trig on child3; drop trigger child3_update_trig on child3; drop trigger child3_delete_trig on child3; delete from parent; NOTICE: trigger = parent_delete_trig, old table = (AAA,42), (BBB,42), (CCC,42) drop table child1, child2, child3, parent; -- -- Verify prohibition of row triggers with transition triggers on -- inheritance children -- create table parent (a text, b int); create table child () inherits (parent); -- adding row trigger with transition table fails create trigger child_row_trig after insert on child referencing new table as new_table for each row execute procedure dump_insert(); ERROR: ROW triggers with transition tables are not supported on inheritance children -- disinheriting it first works alter table child no inherit parent; create trigger child_row_trig after insert on child referencing new table as new_table for each row execute procedure dump_insert(); -- but now we're not allowed to make it inherit anymore alter table child inherit parent; ERROR: trigger "child_row_trig" prevents table "child" from becoming an inheritance child DETAIL: ROW triggers with transition tables are not supported in inheritance hierarchies -- drop the trigger, and now we're allowed to make it inherit again drop trigger child_row_trig on child; alter table child inherit parent; drop table child, parent; -- -- Verify behavior of queries with wCTEs, where multiple transition -- tuplestores can be active at the same time because there are -- multiple DML statements that might fire triggers with transition -- tables -- create table table1 (a int); create table table2 (a text); create trigger table1_trig after insert on table1 referencing new table as new_table for each statement execute procedure dump_insert(); create trigger table2_trig after insert on table2 referencing new table as new_table for each statement execute procedure dump_insert(); with wcte as (insert into table1 values (42)) insert into table2 values ('hello world'); NOTICE: trigger = table2_trig, new table = ("hello world") NOTICE: trigger = table1_trig, new table = (42) drop table table1; drop table table2; -- cleanup drop function dump_insert(); drop function dump_update(); drop function dump_delete();