2012-07-18 16:16:16 +02:00
|
|
|
-- should fail, return type mismatch
|
|
|
|
create event trigger regress_event_trigger
|
|
|
|
on ddl_command_start
|
|
|
|
execute procedure pg_backend_pid();
|
|
|
|
|
2012-07-20 17:38:47 +02:00
|
|
|
-- OK
|
|
|
|
create function test_event_trigger() returns event_trigger as $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE 'test_event_trigger: % %', tg_event, tg_tag;
|
|
|
|
END
|
|
|
|
$$ language plpgsql;
|
2012-07-18 16:16:16 +02:00
|
|
|
|
Fix confusion about event trigger vs. plain function in plpgsql.
The function hash table keys made by compute_function_hashkey() failed
to distinguish event-trigger call context from regular call context.
This meant that once we'd successfully made a hash entry for an event
trigger (either by validation, or by normal use as an event trigger),
an attempt to call the trigger function as a plain function would
find this hash entry and thereby bypass the you-can't-do-that check in
do_compile(). Thus we'd attempt to execute the function, leading to
strange errors or even crashes, depending on function contents and
server version.
To fix, add an isEventTrigger field to PLpgSQL_func_hashkey,
paralleling the longstanding infrastructure for regular triggers.
This fits into what had been pad space, so there's no risk of an ABI
break, even assuming that any third-party code is looking at these
hash keys. (I considered replacing isTrigger with a PLpgSQL_trigtype
enum field, but felt that that carried some API/ABI risk. Maybe we
should change it in HEAD though.)
Per bug #16266 from Alexander Lakhin. This has been broken since
event triggers were invented, so back-patch to all supported branches.
Discussion: https://postgr.es/m/16266-fcd7f838e97ba5d4@postgresql.org
2020-02-19 20:44:58 +01:00
|
|
|
-- should fail, can't call it as a plain function
|
|
|
|
SELECT test_event_trigger();
|
|
|
|
|
2015-03-06 23:14:28 +01:00
|
|
|
-- should fail, event triggers cannot have declared arguments
|
|
|
|
create function test_event_trigger_arg(name text)
|
|
|
|
returns event_trigger as $$ BEGIN RETURN 1; END $$ language plpgsql;
|
|
|
|
|
|
|
|
-- should fail, SQL functions cannot be event triggers
|
|
|
|
create function test_event_trigger_sql() returns event_trigger as $$
|
|
|
|
SELECT 1 $$ language sql;
|
|
|
|
|
2012-07-18 16:16:16 +02:00
|
|
|
-- should fail, no elephant_bootstrap entry point
|
|
|
|
create event trigger regress_event_trigger on elephant_bootstrap
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- OK
|
|
|
|
create event trigger regress_event_trigger on ddl_command_start
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
2013-01-23 12:46:27 +01:00
|
|
|
-- OK
|
2013-01-22 00:00:24 +01:00
|
|
|
create event trigger regress_event_trigger_end on ddl_command_end
|
2018-10-01 23:02:55 +02:00
|
|
|
execute function test_event_trigger();
|
2013-01-22 00:00:24 +01:00
|
|
|
|
2012-07-18 16:16:16 +02:00
|
|
|
-- should fail, food is not a valid filter variable
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
2016-06-03 16:13:36 +02:00
|
|
|
when food in ('sandwich')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
2016-06-03 16:13:36 +02:00
|
|
|
-- should fail, sandwich is not a valid command tag
|
2012-07-18 16:16:16 +02:00
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
2016-06-03 16:13:36 +02:00
|
|
|
when tag in ('sandwich')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
2015-05-17 14:57:30 +02:00
|
|
|
-- should fail, create skunkcabbage is not a valid command tag
|
2012-07-18 16:16:16 +02:00
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('create table', 'create skunkcabbage')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- should fail, can't have event triggers on event triggers
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('DROP EVENT TRIGGER')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
2015-03-06 23:14:28 +01:00
|
|
|
-- should fail, can't have event triggers on global objects
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('CREATE ROLE')
|
|
|
|
execute procedure test_event_trigger();
|
|
|
|
|
|
|
|
-- should fail, can't have event triggers on global objects
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('CREATE DATABASE')
|
|
|
|
execute procedure test_event_trigger();
|
|
|
|
|
|
|
|
-- should fail, can't have event triggers on global objects
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('CREATE TABLESPACE')
|
|
|
|
execute procedure test_event_trigger();
|
|
|
|
|
2012-07-18 16:16:16 +02:00
|
|
|
-- should fail, can't have same filter variable twice
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('create table') and tag in ('CREATE FUNCTION')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
2015-03-06 23:14:28 +01:00
|
|
|
-- should fail, can't have arguments
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
execute procedure test_event_trigger('argument not allowed');
|
|
|
|
|
2012-07-18 16:16:16 +02:00
|
|
|
-- OK
|
|
|
|
create event trigger regress_event_trigger2 on ddl_command_start
|
|
|
|
when tag in ('create table', 'CREATE FUNCTION')
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- OK
|
|
|
|
comment on event trigger regress_event_trigger is 'test comment';
|
|
|
|
|
|
|
|
-- drop as non-superuser should fail
|
2016-07-18 00:42:31 +02:00
|
|
|
create role regress_evt_user;
|
|
|
|
set role regress_evt_user;
|
2012-07-18 16:16:16 +02:00
|
|
|
create event trigger regress_event_trigger_noperms on ddl_command_start
|
2012-07-20 17:38:47 +02:00
|
|
|
execute procedure test_event_trigger();
|
2012-07-18 16:16:16 +02:00
|
|
|
reset role;
|
|
|
|
|
2018-01-18 17:24:07 +01:00
|
|
|
-- test enabling and disabling
|
|
|
|
alter event trigger regress_event_trigger disable;
|
|
|
|
-- fires _trigger2 and _trigger_end should fire, but not _trigger
|
|
|
|
create table event_trigger_fire1 (a int);
|
|
|
|
alter event trigger regress_event_trigger enable;
|
|
|
|
set session_replication_role = replica;
|
|
|
|
-- fires nothing
|
|
|
|
create table event_trigger_fire2 (a int);
|
2012-07-18 16:16:16 +02:00
|
|
|
alter event trigger regress_event_trigger enable replica;
|
2018-01-18 17:24:07 +01:00
|
|
|
-- fires only _trigger
|
|
|
|
create table event_trigger_fire3 (a int);
|
2012-07-18 16:16:16 +02:00
|
|
|
alter event trigger regress_event_trigger enable always;
|
2018-01-18 17:24:07 +01:00
|
|
|
-- fires only _trigger
|
|
|
|
create table event_trigger_fire4 (a int);
|
|
|
|
reset session_replication_role;
|
|
|
|
-- fires all three
|
|
|
|
create table event_trigger_fire5 (a int);
|
2018-10-05 15:20:01 +02:00
|
|
|
-- non-top-level command
|
|
|
|
create function f1() returns int
|
|
|
|
language plpgsql
|
|
|
|
as $$
|
|
|
|
begin
|
|
|
|
create table event_trigger_fire6 (a int);
|
|
|
|
return 0;
|
|
|
|
end $$;
|
|
|
|
select f1();
|
|
|
|
-- non-top-level command
|
|
|
|
create procedure p1()
|
|
|
|
language plpgsql
|
|
|
|
as $$
|
|
|
|
begin
|
|
|
|
create table event_trigger_fire7 (a int);
|
|
|
|
end $$;
|
|
|
|
call p1();
|
|
|
|
|
2018-01-18 17:24:07 +01:00
|
|
|
-- clean up
|
2012-07-20 17:38:47 +02:00
|
|
|
alter event trigger regress_event_trigger disable;
|
2018-10-05 15:20:01 +02:00
|
|
|
drop table event_trigger_fire2, event_trigger_fire3, event_trigger_fire4, event_trigger_fire5, event_trigger_fire6, event_trigger_fire7;
|
|
|
|
drop routine f1(), p1();
|
2012-07-20 17:38:47 +02:00
|
|
|
|
2015-03-06 23:14:28 +01:00
|
|
|
-- regress_event_trigger_end should fire on these commands
|
|
|
|
grant all on table event_trigger_fire1 to public;
|
|
|
|
comment on table event_trigger_fire1 is 'here is a comment';
|
|
|
|
revoke all on table event_trigger_fire1 from public;
|
2012-07-20 17:38:47 +02:00
|
|
|
drop table event_trigger_fire1;
|
2015-03-11 21:01:13 +01:00
|
|
|
create foreign data wrapper useless;
|
|
|
|
create server useless_server foreign data wrapper useless;
|
2016-07-18 00:42:31 +02:00
|
|
|
create user mapping for regress_evt_user server useless_server;
|
|
|
|
alter default privileges for role regress_evt_user
|
|
|
|
revoke delete on tables from regress_evt_user;
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- alter owner to non-superuser should fail
|
2016-07-18 00:42:31 +02:00
|
|
|
alter event trigger regress_event_trigger owner to regress_evt_user;
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- alter owner to superuser should work
|
2016-07-18 00:42:31 +02:00
|
|
|
alter role regress_evt_user superuser;
|
|
|
|
alter event trigger regress_event_trigger owner to regress_evt_user;
|
2012-07-18 16:16:16 +02:00
|
|
|
|
|
|
|
-- should fail, name collision
|
|
|
|
alter event trigger regress_event_trigger rename to regress_event_trigger2;
|
|
|
|
|
|
|
|
-- OK
|
|
|
|
alter event trigger regress_event_trigger rename to regress_event_trigger3;
|
|
|
|
|
|
|
|
-- should fail, doesn't exist any more
|
|
|
|
drop event trigger regress_event_trigger;
|
|
|
|
|
2016-07-18 00:42:31 +02:00
|
|
|
-- should fail, regress_evt_user owns some objects
|
|
|
|
drop role regress_evt_user;
|
2012-07-18 16:16:16 +02:00
|
|
|
|
Add sql_drop event for event triggers
This event takes place just before ddl_command_end, and is fired if and
only if at least one object has been dropped by the command. (For
instance, DROP TABLE IF EXISTS of a table that does not in fact exist
will not lead to such a trigger firing). Commands that drop multiple
objects (such as DROP SCHEMA or DROP OWNED BY) will cause a single event
to fire. Some firings might be surprising, such as
ALTER TABLE DROP COLUMN.
The trigger is fired after the drop has taken place, because that has
been deemed the safest design, to avoid exposing possibly-inconsistent
internal state (system catalogs as well as current transaction) to the
user function code. This means that careful tracking of object
identification is required during the object removal phase.
Like other currently existing events, there is support for tag
filtering.
To support the new event, add a new pg_event_trigger_dropped_objects()
set-returning function, which returns a set of rows comprising the
objects affected by the command. This is to be used within the user
function code, and is mostly modelled after the recently introduced
pg_identify_object() function.
Catalog version bumped due to the new function.
Dimitri Fontaine and Álvaro Herrera
Review by Robert Haas, Tom Lane
2013-03-27 20:02:10 +01:00
|
|
|
-- cleanup before next test
|
2012-07-18 16:16:16 +02:00
|
|
|
-- these are all OK; the second one should emit a NOTICE
|
|
|
|
drop event trigger if exists regress_event_trigger2;
|
|
|
|
drop event trigger if exists regress_event_trigger2;
|
|
|
|
drop event trigger regress_event_trigger3;
|
2013-01-22 00:00:24 +01:00
|
|
|
drop event trigger regress_event_trigger_end;
|
Add sql_drop event for event triggers
This event takes place just before ddl_command_end, and is fired if and
only if at least one object has been dropped by the command. (For
instance, DROP TABLE IF EXISTS of a table that does not in fact exist
will not lead to such a trigger firing). Commands that drop multiple
objects (such as DROP SCHEMA or DROP OWNED BY) will cause a single event
to fire. Some firings might be surprising, such as
ALTER TABLE DROP COLUMN.
The trigger is fired after the drop has taken place, because that has
been deemed the safest design, to avoid exposing possibly-inconsistent
internal state (system catalogs as well as current transaction) to the
user function code. This means that careful tracking of object
identification is required during the object removal phase.
Like other currently existing events, there is support for tag
filtering.
To support the new event, add a new pg_event_trigger_dropped_objects()
set-returning function, which returns a set of rows comprising the
objects affected by the command. This is to be used within the user
function code, and is mostly modelled after the recently introduced
pg_identify_object() function.
Catalog version bumped due to the new function.
Dimitri Fontaine and Álvaro Herrera
Review by Robert Haas, Tom Lane
2013-03-27 20:02:10 +01:00
|
|
|
|
|
|
|
-- test support for dropped objects
|
2016-07-18 00:42:31 +02:00
|
|
|
CREATE SCHEMA schema_one authorization regress_evt_user;
|
|
|
|
CREATE SCHEMA schema_two authorization regress_evt_user;
|
|
|
|
CREATE SCHEMA audit_tbls authorization regress_evt_user;
|
2015-04-06 16:40:55 +02:00
|
|
|
CREATE TEMP TABLE a_temp_tbl ();
|
2016-07-18 00:42:31 +02:00
|
|
|
SET SESSION AUTHORIZATION regress_evt_user;
|
Add sql_drop event for event triggers
This event takes place just before ddl_command_end, and is fired if and
only if at least one object has been dropped by the command. (For
instance, DROP TABLE IF EXISTS of a table that does not in fact exist
will not lead to such a trigger firing). Commands that drop multiple
objects (such as DROP SCHEMA or DROP OWNED BY) will cause a single event
to fire. Some firings might be surprising, such as
ALTER TABLE DROP COLUMN.
The trigger is fired after the drop has taken place, because that has
been deemed the safest design, to avoid exposing possibly-inconsistent
internal state (system catalogs as well as current transaction) to the
user function code. This means that careful tracking of object
identification is required during the object removal phase.
Like other currently existing events, there is support for tag
filtering.
To support the new event, add a new pg_event_trigger_dropped_objects()
set-returning function, which returns a set of rows comprising the
objects affected by the command. This is to be used within the user
function code, and is mostly modelled after the recently introduced
pg_identify_object() function.
Catalog version bumped due to the new function.
Dimitri Fontaine and Álvaro Herrera
Review by Robert Haas, Tom Lane
2013-03-27 20:02:10 +01:00
|
|
|
|
|
|
|
CREATE TABLE schema_one.table_one(a int);
|
|
|
|
CREATE TABLE schema_one."table two"(a int);
|
|
|
|
CREATE TABLE schema_one.table_three(a int);
|
|
|
|
CREATE TABLE audit_tbls.schema_one_table_two(the_value text);
|
|
|
|
|
|
|
|
CREATE TABLE schema_two.table_two(a int);
|
|
|
|
CREATE TABLE schema_two.table_three(a int, b text);
|
|
|
|
CREATE TABLE audit_tbls.schema_two_table_three(the_value text);
|
|
|
|
|
|
|
|
CREATE OR REPLACE FUNCTION schema_two.add(int, int) RETURNS int LANGUAGE plpgsql
|
|
|
|
CALLED ON NULL INPUT
|
|
|
|
AS $$ BEGIN RETURN coalesce($1,0) + coalesce($2,0); END; $$;
|
|
|
|
CREATE AGGREGATE schema_two.newton
|
|
|
|
(BASETYPE = int, SFUNC = schema_two.add, STYPE = int);
|
|
|
|
|
|
|
|
RESET SESSION AUTHORIZATION;
|
|
|
|
|
|
|
|
CREATE TABLE undroppable_objs (
|
|
|
|
object_type text,
|
|
|
|
object_identity text
|
|
|
|
);
|
|
|
|
INSERT INTO undroppable_objs VALUES
|
|
|
|
('table', 'schema_one.table_three'),
|
|
|
|
('table', 'audit_tbls.schema_two_table_three');
|
|
|
|
|
|
|
|
CREATE TABLE dropped_objects (
|
|
|
|
type text,
|
|
|
|
schema text,
|
|
|
|
object text
|
|
|
|
);
|
|
|
|
|
|
|
|
-- This tests errors raised within event triggers; the one in audit_tbls
|
|
|
|
-- uses 2nd-level recursive invocation via test_evtrig_dropped_objects().
|
|
|
|
CREATE OR REPLACE FUNCTION undroppable() RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql AS $$
|
|
|
|
DECLARE
|
|
|
|
obj record;
|
|
|
|
BEGIN
|
|
|
|
PERFORM 1 FROM pg_tables WHERE tablename = 'undroppable_objs';
|
|
|
|
IF NOT FOUND THEN
|
|
|
|
RAISE NOTICE 'table undroppable_objs not found, skipping';
|
|
|
|
RETURN;
|
|
|
|
END IF;
|
|
|
|
FOR obj IN
|
|
|
|
SELECT * FROM pg_event_trigger_dropped_objects() JOIN
|
|
|
|
undroppable_objs USING (object_type, object_identity)
|
|
|
|
LOOP
|
|
|
|
RAISE EXCEPTION 'object % of type % cannot be dropped',
|
|
|
|
obj.object_identity, obj.object_type;
|
|
|
|
END LOOP;
|
|
|
|
END;
|
|
|
|
$$;
|
|
|
|
|
|
|
|
CREATE EVENT TRIGGER undroppable ON sql_drop
|
|
|
|
EXECUTE PROCEDURE undroppable();
|
|
|
|
|
|
|
|
CREATE OR REPLACE FUNCTION test_evtrig_dropped_objects() RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql AS $$
|
|
|
|
DECLARE
|
|
|
|
obj record;
|
|
|
|
BEGIN
|
|
|
|
FOR obj IN SELECT * FROM pg_event_trigger_dropped_objects()
|
|
|
|
LOOP
|
|
|
|
IF obj.object_type = 'table' THEN
|
|
|
|
EXECUTE format('DROP TABLE IF EXISTS audit_tbls.%I',
|
|
|
|
format('%s_%s', obj.schema_name, obj.object_name));
|
|
|
|
END IF;
|
|
|
|
|
|
|
|
INSERT INTO dropped_objects
|
|
|
|
(type, schema, object) VALUES
|
|
|
|
(obj.object_type, obj.schema_name, obj.object_identity);
|
|
|
|
END LOOP;
|
|
|
|
END
|
|
|
|
$$;
|
|
|
|
|
|
|
|
CREATE EVENT TRIGGER regress_event_trigger_drop_objects ON sql_drop
|
|
|
|
WHEN TAG IN ('drop table', 'drop function', 'drop view',
|
|
|
|
'drop owned', 'drop schema', 'alter table')
|
|
|
|
EXECUTE PROCEDURE test_evtrig_dropped_objects();
|
|
|
|
|
|
|
|
ALTER TABLE schema_one.table_one DROP COLUMN a;
|
|
|
|
DROP SCHEMA schema_one, schema_two CASCADE;
|
|
|
|
DELETE FROM undroppable_objs WHERE object_identity = 'audit_tbls.schema_two_table_three';
|
|
|
|
DROP SCHEMA schema_one, schema_two CASCADE;
|
|
|
|
DELETE FROM undroppable_objs WHERE object_identity = 'schema_one.table_three';
|
|
|
|
DROP SCHEMA schema_one, schema_two CASCADE;
|
|
|
|
|
|
|
|
SELECT * FROM dropped_objects WHERE schema IS NULL OR schema <> 'pg_toast';
|
|
|
|
|
2016-07-18 00:42:31 +02:00
|
|
|
DROP OWNED BY regress_evt_user;
|
Add sql_drop event for event triggers
This event takes place just before ddl_command_end, and is fired if and
only if at least one object has been dropped by the command. (For
instance, DROP TABLE IF EXISTS of a table that does not in fact exist
will not lead to such a trigger firing). Commands that drop multiple
objects (such as DROP SCHEMA or DROP OWNED BY) will cause a single event
to fire. Some firings might be surprising, such as
ALTER TABLE DROP COLUMN.
The trigger is fired after the drop has taken place, because that has
been deemed the safest design, to avoid exposing possibly-inconsistent
internal state (system catalogs as well as current transaction) to the
user function code. This means that careful tracking of object
identification is required during the object removal phase.
Like other currently existing events, there is support for tag
filtering.
To support the new event, add a new pg_event_trigger_dropped_objects()
set-returning function, which returns a set of rows comprising the
objects affected by the command. This is to be used within the user
function code, and is mostly modelled after the recently introduced
pg_identify_object() function.
Catalog version bumped due to the new function.
Dimitri Fontaine and Álvaro Herrera
Review by Robert Haas, Tom Lane
2013-03-27 20:02:10 +01:00
|
|
|
SELECT * FROM dropped_objects WHERE type = 'schema';
|
|
|
|
|
2016-07-18 00:42:31 +02:00
|
|
|
DROP ROLE regress_evt_user;
|
Add sql_drop event for event triggers
This event takes place just before ddl_command_end, and is fired if and
only if at least one object has been dropped by the command. (For
instance, DROP TABLE IF EXISTS of a table that does not in fact exist
will not lead to such a trigger firing). Commands that drop multiple
objects (such as DROP SCHEMA or DROP OWNED BY) will cause a single event
to fire. Some firings might be surprising, such as
ALTER TABLE DROP COLUMN.
The trigger is fired after the drop has taken place, because that has
been deemed the safest design, to avoid exposing possibly-inconsistent
internal state (system catalogs as well as current transaction) to the
user function code. This means that careful tracking of object
identification is required during the object removal phase.
Like other currently existing events, there is support for tag
filtering.
To support the new event, add a new pg_event_trigger_dropped_objects()
set-returning function, which returns a set of rows comprising the
objects affected by the command. This is to be used within the user
function code, and is mostly modelled after the recently introduced
pg_identify_object() function.
Catalog version bumped due to the new function.
Dimitri Fontaine and Álvaro Herrera
Review by Robert Haas, Tom Lane
2013-03-27 20:02:10 +01:00
|
|
|
|
|
|
|
DROP EVENT TRIGGER regress_event_trigger_drop_objects;
|
|
|
|
DROP EVENT TRIGGER undroppable;
|
2014-12-07 16:55:28 +01:00
|
|
|
|
2021-06-14 07:57:22 +02:00
|
|
|
-- Event triggers on relations.
|
2014-12-19 19:00:45 +01:00
|
|
|
CREATE OR REPLACE FUNCTION event_trigger_report_dropped()
|
|
|
|
RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql
|
|
|
|
AS $$
|
|
|
|
DECLARE r record;
|
|
|
|
BEGIN
|
|
|
|
FOR r IN SELECT * from pg_event_trigger_dropped_objects()
|
|
|
|
LOOP
|
|
|
|
IF NOT r.normal AND NOT r.original THEN
|
|
|
|
CONTINUE;
|
|
|
|
END IF;
|
2015-04-06 16:40:55 +02:00
|
|
|
RAISE NOTICE 'NORMAL: orig=% normal=% istemp=% type=% identity=% name=% args=%',
|
|
|
|
r.original, r.normal, r.is_temporary, r.object_type,
|
|
|
|
r.object_identity, r.address_names, r.address_args;
|
2014-12-19 19:00:45 +01:00
|
|
|
END LOOP;
|
|
|
|
END; $$;
|
|
|
|
CREATE EVENT TRIGGER regress_event_trigger_report_dropped ON sql_drop
|
|
|
|
EXECUTE PROCEDURE event_trigger_report_dropped();
|
2021-06-14 07:57:22 +02:00
|
|
|
CREATE OR REPLACE FUNCTION event_trigger_report_end()
|
|
|
|
RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql
|
|
|
|
AS $$
|
|
|
|
DECLARE r RECORD;
|
|
|
|
BEGIN
|
|
|
|
FOR r IN SELECT * FROM pg_event_trigger_ddl_commands()
|
|
|
|
LOOP
|
|
|
|
RAISE NOTICE 'END: command_tag=% type=% identity=%',
|
|
|
|
r.command_tag, r.object_type, r.object_identity;
|
|
|
|
END LOOP;
|
|
|
|
END; $$;
|
|
|
|
CREATE EVENT TRIGGER regress_event_trigger_report_end ON ddl_command_end
|
|
|
|
EXECUTE PROCEDURE event_trigger_report_end();
|
|
|
|
|
2014-12-19 19:00:45 +01:00
|
|
|
CREATE SCHEMA evttrig
|
2021-06-14 07:57:22 +02:00
|
|
|
CREATE TABLE one (col_a SERIAL PRIMARY KEY, col_b text DEFAULT 'forty two', col_c SERIAL)
|
2014-12-19 19:00:45 +01:00
|
|
|
CREATE INDEX one_idx ON one (col_b)
|
2021-06-14 07:57:22 +02:00
|
|
|
CREATE TABLE two (col_c INTEGER CHECK (col_c > 0) REFERENCES one DEFAULT 42)
|
|
|
|
CREATE TABLE id (col_d int NOT NULL GENERATED ALWAYS AS IDENTITY);
|
2014-12-19 19:00:45 +01:00
|
|
|
|
2018-10-07 00:17:46 +02:00
|
|
|
-- Partitioned tables with a partitioned index
|
|
|
|
CREATE TABLE evttrig.parted (
|
|
|
|
id int PRIMARY KEY)
|
|
|
|
PARTITION BY RANGE (id);
|
|
|
|
CREATE TABLE evttrig.part_1_10 PARTITION OF evttrig.parted (id)
|
|
|
|
FOR VALUES FROM (1) TO (10);
|
|
|
|
CREATE TABLE evttrig.part_10_20 PARTITION OF evttrig.parted (id)
|
|
|
|
FOR VALUES FROM (10) TO (20) PARTITION BY RANGE (id);
|
|
|
|
CREATE TABLE evttrig.part_10_15 PARTITION OF evttrig.part_10_20 (id)
|
|
|
|
FOR VALUES FROM (10) TO (15);
|
|
|
|
CREATE TABLE evttrig.part_15_20 PARTITION OF evttrig.part_10_20 (id)
|
|
|
|
FOR VALUES FROM (15) TO (20);
|
|
|
|
|
2014-12-19 19:00:45 +01:00
|
|
|
ALTER TABLE evttrig.two DROP COLUMN col_c;
|
|
|
|
ALTER TABLE evttrig.one ALTER COLUMN col_b DROP DEFAULT;
|
|
|
|
ALTER TABLE evttrig.one DROP CONSTRAINT one_pkey;
|
2021-06-14 07:57:22 +02:00
|
|
|
ALTER TABLE evttrig.one DROP COLUMN col_c;
|
|
|
|
ALTER TABLE evttrig.id ALTER COLUMN col_d SET DATA TYPE bigint;
|
|
|
|
ALTER TABLE evttrig.id ALTER COLUMN col_d DROP IDENTITY,
|
|
|
|
ALTER COLUMN col_d SET DATA TYPE int;
|
2014-12-19 19:00:45 +01:00
|
|
|
DROP INDEX evttrig.one_idx;
|
|
|
|
DROP SCHEMA evttrig CASCADE;
|
2015-04-06 16:40:55 +02:00
|
|
|
DROP TABLE a_temp_tbl;
|
2014-12-19 19:00:45 +01:00
|
|
|
|
2022-05-20 18:52:55 +02:00
|
|
|
-- CREATE OPERATOR CLASS without FAMILY clause should report
|
|
|
|
-- both CREATE OPERATOR FAMILY and CREATE OPERATOR CLASS
|
|
|
|
CREATE OPERATOR CLASS evttrigopclass FOR TYPE int USING btree AS STORAGE int;
|
|
|
|
|
2014-12-19 19:00:45 +01:00
|
|
|
DROP EVENT TRIGGER regress_event_trigger_report_dropped;
|
2021-06-14 07:57:22 +02:00
|
|
|
DROP EVENT TRIGGER regress_event_trigger_report_end;
|
2014-12-19 19:00:45 +01:00
|
|
|
|
2014-12-07 16:55:28 +01:00
|
|
|
-- only allowed from within an event trigger function, should fail
|
|
|
|
select pg_event_trigger_table_rewrite_oid();
|
|
|
|
|
|
|
|
-- test Table Rewrite Event Trigger
|
|
|
|
CREATE OR REPLACE FUNCTION test_evtrig_no_rewrite() RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql AS $$
|
|
|
|
BEGIN
|
2015-09-05 17:58:20 +02:00
|
|
|
RAISE EXCEPTION 'rewrites not allowed';
|
2014-12-07 16:55:28 +01:00
|
|
|
END;
|
|
|
|
$$;
|
|
|
|
|
|
|
|
create event trigger no_rewrite_allowed on table_rewrite
|
|
|
|
execute procedure test_evtrig_no_rewrite();
|
|
|
|
|
2019-03-09 05:16:27 +01:00
|
|
|
create table rewriteme (id serial primary key, foo float, bar timestamptz);
|
2014-12-07 16:55:28 +01:00
|
|
|
insert into rewriteme
|
|
|
|
select x * 1.001 from generate_series(1, 500) as t(x);
|
|
|
|
alter table rewriteme alter column foo type numeric;
|
|
|
|
alter table rewriteme add column baz int default 0;
|
|
|
|
|
|
|
|
-- test with more than one reason to rewrite a single table
|
|
|
|
CREATE OR REPLACE FUNCTION test_evtrig_no_rewrite() RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql AS $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE 'Table ''%'' is being rewritten (reason = %)',
|
|
|
|
pg_event_trigger_table_rewrite_oid()::regclass,
|
|
|
|
pg_event_trigger_table_rewrite_reason();
|
|
|
|
END;
|
|
|
|
$$;
|
|
|
|
|
|
|
|
alter table rewriteme
|
|
|
|
add column onemore int default 0,
|
|
|
|
add column another int default -1,
|
|
|
|
alter column foo type numeric(10,4);
|
|
|
|
|
|
|
|
-- shouldn't trigger a table_rewrite event
|
|
|
|
alter table rewriteme alter column foo type numeric(12,4);
|
2019-03-09 05:16:27 +01:00
|
|
|
begin;
|
|
|
|
set timezone to 'UTC';
|
|
|
|
alter table rewriteme alter column bar type timestamp;
|
|
|
|
set timezone to '0';
|
|
|
|
alter table rewriteme alter column bar type timestamptz;
|
|
|
|
set timezone to 'Europe/London';
|
|
|
|
alter table rewriteme alter column bar type timestamp; -- does rewrite
|
|
|
|
rollback;
|
2014-12-07 16:55:28 +01:00
|
|
|
|
2015-03-01 15:58:07 +01:00
|
|
|
-- typed tables are rewritten when their type changes. Don't emit table
|
|
|
|
-- name, because firing order is not stable.
|
|
|
|
CREATE OR REPLACE FUNCTION test_evtrig_no_rewrite() RETURNS event_trigger
|
|
|
|
LANGUAGE plpgsql AS $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE 'Table is being rewritten (reason = %)',
|
|
|
|
pg_event_trigger_table_rewrite_reason();
|
|
|
|
END;
|
|
|
|
$$;
|
|
|
|
|
2015-02-27 22:38:33 +01:00
|
|
|
create type rewritetype as (a int);
|
|
|
|
create table rewritemetoo1 of rewritetype;
|
|
|
|
create table rewritemetoo2 of rewritetype;
|
|
|
|
alter type rewritetype alter attribute a type text cascade;
|
|
|
|
|
|
|
|
-- but this doesn't work
|
|
|
|
create table rewritemetoo3 (a rewritetype);
|
|
|
|
alter type rewritetype alter attribute a type varchar cascade;
|
|
|
|
|
2014-12-07 16:55:28 +01:00
|
|
|
drop table rewriteme;
|
|
|
|
drop event trigger no_rewrite_allowed;
|
|
|
|
drop function test_evtrig_no_rewrite();
|
2015-01-02 21:09:39 +01:00
|
|
|
|
|
|
|
-- test Row Security Event Trigger
|
|
|
|
RESET SESSION AUTHORIZATION;
|
|
|
|
CREATE TABLE event_trigger_test (a integer, b text);
|
|
|
|
|
|
|
|
CREATE OR REPLACE FUNCTION start_command()
|
|
|
|
RETURNS event_trigger AS $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE '% - ddl_command_start', tg_tag;
|
|
|
|
END;
|
|
|
|
$$ LANGUAGE plpgsql;
|
|
|
|
|
|
|
|
CREATE OR REPLACE FUNCTION end_command()
|
|
|
|
RETURNS event_trigger AS $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE '% - ddl_command_end', tg_tag;
|
|
|
|
END;
|
|
|
|
$$ LANGUAGE plpgsql;
|
|
|
|
|
|
|
|
CREATE OR REPLACE FUNCTION drop_sql_command()
|
|
|
|
RETURNS event_trigger AS $$
|
|
|
|
BEGIN
|
|
|
|
RAISE NOTICE '% - sql_drop', tg_tag;
|
|
|
|
END;
|
|
|
|
$$ LANGUAGE plpgsql;
|
|
|
|
|
|
|
|
CREATE EVENT TRIGGER start_rls_command ON ddl_command_start
|
|
|
|
WHEN TAG IN ('CREATE POLICY', 'ALTER POLICY', 'DROP POLICY') EXECUTE PROCEDURE start_command();
|
|
|
|
|
|
|
|
CREATE EVENT TRIGGER end_rls_command ON ddl_command_end
|
|
|
|
WHEN TAG IN ('CREATE POLICY', 'ALTER POLICY', 'DROP POLICY') EXECUTE PROCEDURE end_command();
|
|
|
|
|
|
|
|
CREATE EVENT TRIGGER sql_drop_command ON sql_drop
|
|
|
|
WHEN TAG IN ('DROP POLICY') EXECUTE PROCEDURE drop_sql_command();
|
|
|
|
|
|
|
|
CREATE POLICY p1 ON event_trigger_test USING (FALSE);
|
|
|
|
ALTER POLICY p1 ON event_trigger_test USING (TRUE);
|
|
|
|
ALTER POLICY p1 ON event_trigger_test RENAME TO p2;
|
|
|
|
DROP POLICY p2 ON event_trigger_test;
|
|
|
|
|
2021-04-28 04:17:58 +02:00
|
|
|
-- Check the object addresses of all the event triggers.
|
|
|
|
SELECT
|
|
|
|
e.evtname,
|
|
|
|
pg_describe_object('pg_event_trigger'::regclass, e.oid, 0) as descr,
|
|
|
|
b.type, b.object_names, b.object_args,
|
|
|
|
pg_identify_object(a.classid, a.objid, a.objsubid) as ident
|
|
|
|
FROM pg_event_trigger as e,
|
|
|
|
LATERAL pg_identify_object_as_address('pg_event_trigger'::regclass, e.oid, 0) as b,
|
|
|
|
LATERAL pg_get_object_address(b.type, b.object_names, b.object_args) as a
|
|
|
|
ORDER BY e.evtname;
|
|
|
|
|
2015-01-02 21:09:39 +01:00
|
|
|
DROP EVENT TRIGGER start_rls_command;
|
|
|
|
DROP EVENT TRIGGER end_rls_command;
|
|
|
|
DROP EVENT TRIGGER sql_drop_command;
|