-- -- 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, 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'); 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 -- 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 -- 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); NOTICE: CREATE TABLE will create implicit sequence "trigtest_i_seq" for serial column "trigtest.i" NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "trigtest_pkey" for table "trigtest" -- 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;