-- -- RULES -- From Jan's original setup_ruletest.sql and run_ruletest.sql -- - thomas 1998-09-13 -- -- -- Tables and rules for the view test -- create table rtest_t1 (a int4, b int4); create table rtest_t2 (a int4, b int4); create table rtest_t3 (a int4, b int4); create view rtest_v1 as select * from rtest_t1; create rule rtest_v1_ins as on insert to rtest_v1 do instead insert into rtest_t1 values (new.a, new.b); create rule rtest_v1_upd as on update to rtest_v1 do instead update rtest_t1 set a = new.a, b = new.b where a = old.a; create rule rtest_v1_del as on delete to rtest_v1 do instead delete from rtest_t1 where a = old.a; -- Test comments COMMENT ON RULE rtest_v1_bad ON rtest_v1 IS 'bad rule'; ERROR: rule "rtest_v1_bad" for relation "rtest_v1" does not exist COMMENT ON RULE rtest_v1_del ON rtest_v1 IS 'delete rule'; COMMENT ON RULE rtest_v1_del ON rtest_v1 IS NULL; -- -- Tables and rules for the constraint update/delete test -- -- Note: -- Now that we have multiple action rule support, we check -- both possible syntaxes to define them (The last action -- can but must not have a semicolon at the end). -- create table rtest_system (sysname text, sysdesc text); create table rtest_interface (sysname text, ifname text); create table rtest_person (pname text, pdesc text); create table rtest_admin (pname text, sysname text); create rule rtest_sys_upd as on update to rtest_system do also ( update rtest_interface set sysname = new.sysname where sysname = old.sysname; update rtest_admin set sysname = new.sysname where sysname = old.sysname ); create rule rtest_sys_del as on delete to rtest_system do also ( delete from rtest_interface where sysname = old.sysname; delete from rtest_admin where sysname = old.sysname; ); create rule rtest_pers_upd as on update to rtest_person do also update rtest_admin set pname = new.pname where pname = old.pname; create rule rtest_pers_del as on delete to rtest_person do also delete from rtest_admin where pname = old.pname; -- -- Tables and rules for the logging test -- create table rtest_emp (ename char(20), salary numeric); create table rtest_emplog (ename char(20), who name, action char(10), newsal numeric, oldsal numeric); create table rtest_empmass (ename char(20), salary numeric); create rule rtest_emp_ins as on insert to rtest_emp do insert into rtest_emplog values (new.ename, current_user, 'hired', new.salary, '0.00'); create rule rtest_emp_upd as on update to rtest_emp where new.salary != old.salary do insert into rtest_emplog values (new.ename, current_user, 'honored', new.salary, old.salary); create rule rtest_emp_del as on delete to rtest_emp do insert into rtest_emplog values (old.ename, current_user, 'fired', '0.00', old.salary); -- -- Tables and rules for the multiple cascaded qualified instead -- rule test -- create table rtest_t4 (a int4, b text); create table rtest_t5 (a int4, b text); create table rtest_t6 (a int4, b text); create table rtest_t7 (a int4, b text); create table rtest_t8 (a int4, b text); create table rtest_t9 (a int4, b text); create rule rtest_t4_ins1 as on insert to rtest_t4 where new.a >= 10 and new.a < 20 do instead insert into rtest_t5 values (new.a, new.b); create rule rtest_t4_ins2 as on insert to rtest_t4 where new.a >= 20 and new.a < 30 do insert into rtest_t6 values (new.a, new.b); create rule rtest_t5_ins as on insert to rtest_t5 where new.a > 15 do insert into rtest_t7 values (new.a, new.b); create rule rtest_t6_ins as on insert to rtest_t6 where new.a > 25 do instead insert into rtest_t8 values (new.a, new.b); -- -- Tables and rules for the rule fire order test -- -- As of PG 7.3, the rules should fire in order by name, regardless -- of INSTEAD attributes or creation order. -- create table rtest_order1 (a int4); create table rtest_order2 (a int4, b int4, c text); create sequence rtest_seq; create rule rtest_order_r3 as on insert to rtest_order1 do instead insert into rtest_order2 values (new.a, nextval('rtest_seq'), 'rule 3 - this should run 3rd'); create rule rtest_order_r4 as on insert to rtest_order1 where a < 100 do instead insert into rtest_order2 values (new.a, nextval('rtest_seq'), 'rule 4 - this should run 4th'); create rule rtest_order_r2 as on insert to rtest_order1 do insert into rtest_order2 values (new.a, nextval('rtest_seq'), 'rule 2 - this should run 2nd'); create rule rtest_order_r1 as on insert to rtest_order1 do instead insert into rtest_order2 values (new.a, nextval('rtest_seq'), 'rule 1 - this should run 1st'); -- -- Tables and rules for the instead nothing test -- create table rtest_nothn1 (a int4, b text); create table rtest_nothn2 (a int4, b text); create table rtest_nothn3 (a int4, b text); create table rtest_nothn4 (a int4, b text); create rule rtest_nothn_r1 as on insert to rtest_nothn1 where new.a >= 10 and new.a < 20 do instead nothing; create rule rtest_nothn_r2 as on insert to rtest_nothn1 where new.a >= 30 and new.a < 40 do instead nothing; create rule rtest_nothn_r3 as on insert to rtest_nothn2 where new.a >= 100 do instead insert into rtest_nothn3 values (new.a, new.b); create rule rtest_nothn_r4 as on insert to rtest_nothn2 do instead nothing; -- -- Tests on a view that is select * of a table -- and has insert/update/delete instead rules to -- behave close like the real table. -- -- -- We need test date later -- insert into rtest_t2 values (1, 21); insert into rtest_t2 values (2, 22); insert into rtest_t2 values (3, 23); insert into rtest_t3 values (1, 31); insert into rtest_t3 values (2, 32); insert into rtest_t3 values (3, 33); insert into rtest_t3 values (4, 34); insert into rtest_t3 values (5, 35); -- insert values insert into rtest_v1 values (1, 11); insert into rtest_v1 values (2, 12); select * from rtest_v1; a | b ---+---- 1 | 11 2 | 12 (2 rows) -- delete with constant expression delete from rtest_v1 where a = 1; select * from rtest_v1; a | b ---+---- 2 | 12 (1 row) insert into rtest_v1 values (1, 11); delete from rtest_v1 where b = 12; select * from rtest_v1; a | b ---+---- 1 | 11 (1 row) insert into rtest_v1 values (2, 12); insert into rtest_v1 values (2, 13); select * from rtest_v1; a | b ---+---- 1 | 11 2 | 12 2 | 13 (3 rows) ** Remember the delete rule on rtest_v1: It says ** DO INSTEAD DELETE FROM rtest_t1 WHERE a = old.a ** So this time both rows with a = 2 must get deleted \p ** Remember the delete rule on rtest_v1: It says ** DO INSTEAD DELETE FROM rtest_t1 WHERE a = old.a ** So this time both rows with a = 2 must get deleted \r delete from rtest_v1 where b = 12; select * from rtest_v1; a | b ---+---- 1 | 11 (1 row) delete from rtest_v1; -- insert select insert into rtest_v1 select * from rtest_t2; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 (3 rows) delete from rtest_v1; -- same with swapped targetlist insert into rtest_v1 (b, a) select b, a from rtest_t2; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 (3 rows) -- now with only one target attribute insert into rtest_v1 (a) select a from rtest_t3; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 1 | 2 | 3 | 4 | 5 | (8 rows) select * from rtest_v1 where b isnull; a | b ---+--- 1 | 2 | 3 | 4 | 5 | (5 rows) -- let attribute a differ (must be done on rtest_t1 - see above) update rtest_t1 set a = a + 10 where b isnull; delete from rtest_v1 where b isnull; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 (3 rows) -- now updates with constant expression update rtest_v1 set b = 42 where a = 2; select * from rtest_v1; a | b ---+---- 1 | 21 3 | 23 2 | 42 (3 rows) update rtest_v1 set b = 99 where b = 42; select * from rtest_v1; a | b ---+---- 1 | 21 3 | 23 2 | 99 (3 rows) update rtest_v1 set b = 88 where b < 50; select * from rtest_v1; a | b ---+---- 2 | 99 1 | 88 3 | 88 (3 rows) delete from rtest_v1; insert into rtest_v1 select rtest_t2.a, rtest_t3.b from rtest_t2, rtest_t3 where rtest_t2.a = rtest_t3.a; select * from rtest_v1; a | b ---+---- 1 | 31 2 | 32 3 | 33 (3 rows) -- updates in a mergejoin update rtest_v1 set b = rtest_t2.b from rtest_t2 where rtest_v1.a = rtest_t2.a; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 (3 rows) insert into rtest_v1 select * from rtest_t3; select * from rtest_v1; a | b ---+---- 1 | 21 2 | 22 3 | 23 1 | 31 2 | 32 3 | 33 4 | 34 5 | 35 (8 rows) update rtest_t1 set a = a + 10 where b > 30; select * from rtest_v1; a | b ----+---- 1 | 21 2 | 22 3 | 23 11 | 31 12 | 32 13 | 33 14 | 34 15 | 35 (8 rows) update rtest_v1 set a = rtest_t3.a + 20 from rtest_t3 where rtest_v1.b = rtest_t3.b; select * from rtest_v1; a | b ----+---- 1 | 21 2 | 22 3 | 23 21 | 31 22 | 32 23 | 33 24 | 34 25 | 35 (8 rows) -- -- Test for constraint updates/deletes -- insert into rtest_system values ('orion', 'Linux Jan Wieck'); insert into rtest_system values ('notjw', 'WinNT Jan Wieck (notebook)'); insert into rtest_system values ('neptun', 'Fileserver'); insert into rtest_interface values ('orion', 'eth0'); insert into rtest_interface values ('orion', 'eth1'); insert into rtest_interface values ('notjw', 'eth0'); insert into rtest_interface values ('neptun', 'eth0'); insert into rtest_person values ('jw', 'Jan Wieck'); insert into rtest_person values ('bm', 'Bruce Momjian'); insert into rtest_admin values ('jw', 'orion'); insert into rtest_admin values ('jw', 'notjw'); insert into rtest_admin values ('bm', 'neptun'); update rtest_system set sysname = 'pluto' where sysname = 'neptun'; select * from rtest_interface; sysname | ifname ---------+-------- orion | eth0 orion | eth1 notjw | eth0 pluto | eth0 (4 rows) select * from rtest_admin; pname | sysname -------+--------- jw | orion jw | notjw bm | pluto (3 rows) update rtest_person set pname = 'jwieck' where pdesc = 'Jan Wieck'; -- Note: use ORDER BY here to ensure consistent output across all systems. -- The above UPDATE affects two rows with equal keys, so they could be -- updated in either order depending on the whim of the local qsort(). select * from rtest_admin order by pname, sysname; pname | sysname --------+--------- bm | pluto jwieck | notjw jwieck | orion (3 rows) delete from rtest_system where sysname = 'orion'; select * from rtest_interface; sysname | ifname ---------+-------- notjw | eth0 pluto | eth0 (2 rows) select * from rtest_admin; pname | sysname --------+--------- bm | pluto jwieck | notjw (2 rows) -- -- Rule qualification test -- insert into rtest_emp values ('wiecc', '5000.00'); insert into rtest_emp values ('gates', '80000.00'); update rtest_emp set ename = 'wiecx' where ename = 'wiecc'; update rtest_emp set ename = 'wieck', salary = '6000.00' where ename = 'wiecx'; update rtest_emp set salary = '7000.00' where ename = 'wieck'; delete from rtest_emp where ename = 'gates'; select ename, who = current_user as "matches user", action, newsal, oldsal from rtest_emplog order by ename, action, newsal; ename | matches user | action | newsal | oldsal ----------------------+--------------+------------+----------+---------- gates | t | fired | 0.00 | 80000.00 gates | t | hired | 80000.00 | 0.00 wiecc | t | hired | 5000.00 | 0.00 wieck | t | honored | 6000.00 | 5000.00 wieck | t | honored | 7000.00 | 6000.00 (5 rows) insert into rtest_empmass values ('meyer', '4000.00'); insert into rtest_empmass values ('maier', '5000.00'); insert into rtest_empmass values ('mayr', '6000.00'); insert into rtest_emp select * from rtest_empmass; select ename, who = current_user as "matches user", action, newsal, oldsal from rtest_emplog order by ename, action, newsal; ename | matches user | action | newsal | oldsal ----------------------+--------------+------------+----------+---------- gates | t | fired | 0.00 | 80000.00 gates | t | hired | 80000.00 | 0.00 maier | t | hired | 5000.00 | 0.00 mayr | t | hired | 6000.00 | 0.00 meyer | t | hired | 4000.00 | 0.00 wiecc | t | hired | 5000.00 | 0.00 wieck | t | honored | 6000.00 | 5000.00 wieck | t | honored | 7000.00 | 6000.00 (8 rows) update rtest_empmass set salary = salary + '1000.00'; update rtest_emp set salary = rtest_empmass.salary from rtest_empmass where rtest_emp.ename = rtest_empmass.ename; select ename, who = current_user as "matches user", action, newsal, oldsal from rtest_emplog order by ename, action, newsal; ename | matches user | action | newsal | oldsal ----------------------+--------------+------------+----------+---------- gates | t | fired | 0.00 | 80000.00 gates | t | hired | 80000.00 | 0.00 maier | t | hired | 5000.00 | 0.00 maier | t | honored | 6000.00 | 5000.00 mayr | t | hired | 6000.00 | 0.00 mayr | t | honored | 7000.00 | 6000.00 meyer | t | hired | 4000.00 | 0.00 meyer | t | honored | 5000.00 | 4000.00 wiecc | t | hired | 5000.00 | 0.00 wieck | t | honored | 6000.00 | 5000.00 wieck | t | honored | 7000.00 | 6000.00 (11 rows) delete from rtest_emp using rtest_empmass where rtest_emp.ename = rtest_empmass.ename; select ename, who = current_user as "matches user", action, newsal, oldsal from rtest_emplog order by ename, action, newsal; ename | matches user | action | newsal | oldsal ----------------------+--------------+------------+----------+---------- gates | t | fired | 0.00 | 80000.00 gates | t | hired | 80000.00 | 0.00 maier | t | fired | 0.00 | 6000.00 maier | t | hired | 5000.00 | 0.00 maier | t | honored | 6000.00 | 5000.00 mayr | t | fired | 0.00 | 7000.00 mayr | t | hired | 6000.00 | 0.00 mayr | t | honored | 7000.00 | 6000.00 meyer | t | fired | 0.00 | 5000.00 meyer | t | hired | 4000.00 | 0.00 meyer | t | honored | 5000.00 | 4000.00 wiecc | t | hired | 5000.00 | 0.00 wieck | t | honored | 6000.00 | 5000.00 wieck | t | honored | 7000.00 | 6000.00 (14 rows) -- -- Multiple cascaded qualified instead rule test -- insert into rtest_t4 values (1, 'Record should go to rtest_t4'); insert into rtest_t4 values (2, 'Record should go to rtest_t4'); insert into rtest_t4 values (10, 'Record should go to rtest_t5'); insert into rtest_t4 values (15, 'Record should go to rtest_t5'); insert into rtest_t4 values (19, 'Record should go to rtest_t5 and t7'); insert into rtest_t4 values (20, 'Record should go to rtest_t4 and t6'); insert into rtest_t4 values (26, 'Record should go to rtest_t4 and t8'); insert into rtest_t4 values (28, 'Record should go to rtest_t4 and t8'); insert into rtest_t4 values (30, 'Record should go to rtest_t4'); insert into rtest_t4 values (40, 'Record should go to rtest_t4'); select * from rtest_t4; a | b ----+------------------------------------- 1 | Record should go to rtest_t4 2 | Record should go to rtest_t4 20 | Record should go to rtest_t4 and t6 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 30 | Record should go to rtest_t4 40 | Record should go to rtest_t4 (7 rows) select * from rtest_t5; a | b ----+------------------------------------- 10 | Record should go to rtest_t5 15 | Record should go to rtest_t5 19 | Record should go to rtest_t5 and t7 (3 rows) select * from rtest_t6; a | b ----+------------------------------------- 20 | Record should go to rtest_t4 and t6 (1 row) select * from rtest_t7; a | b ----+------------------------------------- 19 | Record should go to rtest_t5 and t7 (1 row) select * from rtest_t8; a | b ----+------------------------------------- 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 (2 rows) delete from rtest_t4; delete from rtest_t5; delete from rtest_t6; delete from rtest_t7; delete from rtest_t8; insert into rtest_t9 values (1, 'Record should go to rtest_t4'); insert into rtest_t9 values (2, 'Record should go to rtest_t4'); insert into rtest_t9 values (10, 'Record should go to rtest_t5'); insert into rtest_t9 values (15, 'Record should go to rtest_t5'); insert into rtest_t9 values (19, 'Record should go to rtest_t5 and t7'); insert into rtest_t9 values (20, 'Record should go to rtest_t4 and t6'); insert into rtest_t9 values (26, 'Record should go to rtest_t4 and t8'); insert into rtest_t9 values (28, 'Record should go to rtest_t4 and t8'); insert into rtest_t9 values (30, 'Record should go to rtest_t4'); insert into rtest_t9 values (40, 'Record should go to rtest_t4'); insert into rtest_t4 select * from rtest_t9 where a < 20; select * from rtest_t4; a | b ---+------------------------------ 1 | Record should go to rtest_t4 2 | Record should go to rtest_t4 (2 rows) select * from rtest_t5; a | b ----+------------------------------------- 10 | Record should go to rtest_t5 15 | Record should go to rtest_t5 19 | Record should go to rtest_t5 and t7 (3 rows) select * from rtest_t6; a | b ---+--- (0 rows) select * from rtest_t7; a | b ----+------------------------------------- 19 | Record should go to rtest_t5 and t7 (1 row) select * from rtest_t8; a | b ---+--- (0 rows) insert into rtest_t4 select * from rtest_t9 where b ~ 'and t8'; select * from rtest_t4; a | b ----+------------------------------------- 1 | Record should go to rtest_t4 2 | Record should go to rtest_t4 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 (4 rows) select * from rtest_t5; a | b ----+------------------------------------- 10 | Record should go to rtest_t5 15 | Record should go to rtest_t5 19 | Record should go to rtest_t5 and t7 (3 rows) select * from rtest_t6; a | b ---+--- (0 rows) select * from rtest_t7; a | b ----+------------------------------------- 19 | Record should go to rtest_t5 and t7 (1 row) select * from rtest_t8; a | b ----+------------------------------------- 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 (2 rows) insert into rtest_t4 select a + 1, b from rtest_t9 where a in (20, 30, 40); select * from rtest_t4; a | b ----+------------------------------------- 1 | Record should go to rtest_t4 2 | Record should go to rtest_t4 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 21 | Record should go to rtest_t4 and t6 31 | Record should go to rtest_t4 41 | Record should go to rtest_t4 (7 rows) select * from rtest_t5; a | b ----+------------------------------------- 10 | Record should go to rtest_t5 15 | Record should go to rtest_t5 19 | Record should go to rtest_t5 and t7 (3 rows) select * from rtest_t6; a | b ----+------------------------------------- 21 | Record should go to rtest_t4 and t6 (1 row) select * from rtest_t7; a | b ----+------------------------------------- 19 | Record should go to rtest_t5 and t7 (1 row) select * from rtest_t8; a | b ----+------------------------------------- 26 | Record should go to rtest_t4 and t8 28 | Record should go to rtest_t4 and t8 (2 rows) -- -- Check that the ordering of rules fired is correct -- insert into rtest_order1 values (1); select * from rtest_order2; a | b | c ---+---+------------------------------ 1 | 1 | rule 1 - this should run 1st 1 | 2 | rule 2 - this should run 2nd 1 | 3 | rule 3 - this should run 3rd 1 | 4 | rule 4 - this should run 4th (4 rows) -- -- Check if instead nothing w/without qualification works -- insert into rtest_nothn1 values (1, 'want this'); insert into rtest_nothn1 values (2, 'want this'); insert into rtest_nothn1 values (10, 'don''t want this'); insert into rtest_nothn1 values (19, 'don''t want this'); insert into rtest_nothn1 values (20, 'want this'); insert into rtest_nothn1 values (29, 'want this'); insert into rtest_nothn1 values (30, 'don''t want this'); insert into rtest_nothn1 values (39, 'don''t want this'); insert into rtest_nothn1 values (40, 'want this'); insert into rtest_nothn1 values (50, 'want this'); insert into rtest_nothn1 values (60, 'want this'); select * from rtest_nothn1; a | b ----+----------- 1 | want this 2 | want this 20 | want this 29 | want this 40 | want this 50 | want this 60 | want this (7 rows) insert into rtest_nothn2 values (10, 'too small'); insert into rtest_nothn2 values (50, 'too small'); insert into rtest_nothn2 values (100, 'OK'); insert into rtest_nothn2 values (200, 'OK'); select * from rtest_nothn2; a | b ---+--- (0 rows) select * from rtest_nothn3; a | b -----+---- 100 | OK 200 | OK (2 rows) delete from rtest_nothn1; delete from rtest_nothn2; delete from rtest_nothn3; insert into rtest_nothn4 values (1, 'want this'); insert into rtest_nothn4 values (2, 'want this'); insert into rtest_nothn4 values (10, 'don''t want this'); insert into rtest_nothn4 values (19, 'don''t want this'); insert into rtest_nothn4 values (20, 'want this'); insert into rtest_nothn4 values (29, 'want this'); insert into rtest_nothn4 values (30, 'don''t want this'); insert into rtest_nothn4 values (39, 'don''t want this'); insert into rtest_nothn4 values (40, 'want this'); insert into rtest_nothn4 values (50, 'want this'); insert into rtest_nothn4 values (60, 'want this'); insert into rtest_nothn1 select * from rtest_nothn4; select * from rtest_nothn1; a | b ----+----------- 1 | want this 2 | want this 20 | want this 29 | want this 40 | want this 50 | want this 60 | want this (7 rows) delete from rtest_nothn4; insert into rtest_nothn4 values (10, 'too small'); insert into rtest_nothn4 values (50, 'too small'); insert into rtest_nothn4 values (100, 'OK'); insert into rtest_nothn4 values (200, 'OK'); insert into rtest_nothn2 select * from rtest_nothn4; select * from rtest_nothn2; a | b ---+--- (0 rows) select * from rtest_nothn3; a | b -----+---- 100 | OK 200 | OK (2 rows) create table rtest_view1 (a int4, b text, v bool); create table rtest_view2 (a int4); create table rtest_view3 (a int4, b text); create table rtest_view4 (a int4, b text, c int4); create view rtest_vview1 as select a, b from rtest_view1 X where 0 < (select count(*) from rtest_view2 Y where Y.a = X.a); create view rtest_vview2 as select a, b from rtest_view1 where v; create view rtest_vview3 as select a, b from rtest_vview2 X where 0 < (select count(*) from rtest_view2 Y where Y.a = X.a); create view rtest_vview4 as select X.a, X.b, count(Y.a) as refcount from rtest_view1 X, rtest_view2 Y where X.a = Y.a group by X.a, X.b; create function rtest_viewfunc1(int4) returns int4 as 'select count(*)::int4 from rtest_view2 where a = $1' language sql; create view rtest_vview5 as select a, b, rtest_viewfunc1(a) as refcount from rtest_view1; insert into rtest_view1 values (1, 'item 1', 't'); insert into rtest_view1 values (2, 'item 2', 't'); insert into rtest_view1 values (3, 'item 3', 't'); insert into rtest_view1 values (4, 'item 4', 'f'); insert into rtest_view1 values (5, 'item 5', 't'); insert into rtest_view1 values (6, 'item 6', 'f'); insert into rtest_view1 values (7, 'item 7', 't'); insert into rtest_view1 values (8, 'item 8', 't'); insert into rtest_view2 values (2); insert into rtest_view2 values (2); insert into rtest_view2 values (4); insert into rtest_view2 values (5); insert into rtest_view2 values (7); insert into rtest_view2 values (7); insert into rtest_view2 values (7); insert into rtest_view2 values (7); select * from rtest_vview1; a | b ---+-------- 2 | item 2 4 | item 4 5 | item 5 7 | item 7 (4 rows) select * from rtest_vview2; a | b ---+-------- 1 | item 1 2 | item 2 3 | item 3 5 | item 5 7 | item 7 8 | item 8 (6 rows) select * from rtest_vview3; a | b ---+-------- 2 | item 2 5 | item 5 7 | item 7 (3 rows) select * from rtest_vview4 order by a, b; a | b | refcount ---+--------+---------- 2 | item 2 | 2 4 | item 4 | 1 5 | item 5 | 1 7 | item 7 | 4 (4 rows) select * from rtest_vview5; a | b | refcount ---+--------+---------- 1 | item 1 | 0 2 | item 2 | 2 3 | item 3 | 0 4 | item 4 | 1 5 | item 5 | 1 6 | item 6 | 0 7 | item 7 | 4 8 | item 8 | 0 (8 rows) insert into rtest_view3 select * from rtest_vview1 where a < 7; select * from rtest_view3; a | b ---+-------- 2 | item 2 4 | item 4 5 | item 5 (3 rows) delete from rtest_view3; insert into rtest_view3 select * from rtest_vview2 where a != 5 and b !~ '2'; select * from rtest_view3; a | b ---+-------- 1 | item 1 3 | item 3 7 | item 7 8 | item 8 (4 rows) delete from rtest_view3; insert into rtest_view3 select * from rtest_vview3; select * from rtest_view3; a | b ---+-------- 2 | item 2 5 | item 5 7 | item 7 (3 rows) delete from rtest_view3; insert into rtest_view4 select * from rtest_vview4 where 3 > refcount; select * from rtest_view4 order by a, b; a | b | c ---+--------+--- 2 | item 2 | 2 4 | item 4 | 1 5 | item 5 | 1 (3 rows) delete from rtest_view4; insert into rtest_view4 select * from rtest_vview5 where a > 2 and refcount = 0; select * from rtest_view4; a | b | c ---+--------+--- 3 | item 3 | 0 6 | item 6 | 0 8 | item 8 | 0 (3 rows) delete from rtest_view4; -- -- Test for computations in views -- create table rtest_comp ( part text, unit char(4), size float ); create table rtest_unitfact ( unit char(4), factor float ); create view rtest_vcomp as select X.part, (X.size * Y.factor) as size_in_cm from rtest_comp X, rtest_unitfact Y where X.unit = Y.unit; insert into rtest_unitfact values ('m', 100.0); insert into rtest_unitfact values ('cm', 1.0); insert into rtest_unitfact values ('inch', 2.54); insert into rtest_comp values ('p1', 'm', 5.0); insert into rtest_comp values ('p2', 'm', 3.0); insert into rtest_comp values ('p3', 'cm', 5.0); insert into rtest_comp values ('p4', 'cm', 15.0); insert into rtest_comp values ('p5', 'inch', 7.0); insert into rtest_comp values ('p6', 'inch', 4.4); select * from rtest_vcomp order by part; part | size_in_cm ------+-------------------- p1 | 500 p2 | 300 p3 | 5 p4 | 15 p5 | 17.78 p6 | 11.176000000000002 (6 rows) select * from rtest_vcomp where size_in_cm > 10.0 order by size_in_cm using >; part | size_in_cm ------+-------------------- p1 | 500 p2 | 300 p5 | 17.78 p4 | 15 p6 | 11.176000000000002 (5 rows) -- -- In addition run the (slightly modified) queries from the -- programmers manual section on the rule system. -- CREATE TABLE shoe_data ( shoename char(10), -- primary key sh_avail integer, -- available # of pairs slcolor char(10), -- preferred shoelace color slminlen float, -- minimum shoelace length slmaxlen float, -- maximum shoelace length slunit char(8) -- length unit ); CREATE TABLE shoelace_data ( sl_name char(10), -- primary key sl_avail integer, -- available # of pairs sl_color char(10), -- shoelace color sl_len float, -- shoelace length sl_unit char(8) -- length unit ); CREATE TABLE unit ( un_name char(8), -- the primary key un_fact float -- factor to transform to cm ); CREATE VIEW shoe AS SELECT sh.shoename, sh.sh_avail, sh.slcolor, sh.slminlen, sh.slminlen * un.un_fact AS slminlen_cm, sh.slmaxlen, sh.slmaxlen * un.un_fact AS slmaxlen_cm, sh.slunit FROM shoe_data sh, unit un WHERE sh.slunit = un.un_name; CREATE VIEW shoelace AS SELECT s.sl_name, s.sl_avail, s.sl_color, s.sl_len, s.sl_unit, s.sl_len * u.un_fact AS sl_len_cm FROM shoelace_data s, unit u WHERE s.sl_unit = u.un_name; CREATE VIEW shoe_ready AS SELECT rsh.shoename, rsh.sh_avail, rsl.sl_name, rsl.sl_avail, int4smaller(rsh.sh_avail, rsl.sl_avail) AS total_avail FROM shoe rsh, shoelace rsl WHERE rsl.sl_color = rsh.slcolor AND rsl.sl_len_cm >= rsh.slminlen_cm AND rsl.sl_len_cm <= rsh.slmaxlen_cm; INSERT INTO unit VALUES ('cm', 1.0); INSERT INTO unit VALUES ('m', 100.0); INSERT INTO unit VALUES ('inch', 2.54); INSERT INTO shoe_data VALUES ('sh1', 2, 'black', 70.0, 90.0, 'cm'); INSERT INTO shoe_data VALUES ('sh2', 0, 'black', 30.0, 40.0, 'inch'); INSERT INTO shoe_data VALUES ('sh3', 4, 'brown', 50.0, 65.0, 'cm'); INSERT INTO shoe_data VALUES ('sh4', 3, 'brown', 40.0, 50.0, 'inch'); INSERT INTO shoelace_data VALUES ('sl1', 5, 'black', 80.0, 'cm'); INSERT INTO shoelace_data VALUES ('sl2', 6, 'black', 100.0, 'cm'); INSERT INTO shoelace_data VALUES ('sl3', 0, 'black', 35.0 , 'inch'); INSERT INTO shoelace_data VALUES ('sl4', 8, 'black', 40.0 , 'inch'); INSERT INTO shoelace_data VALUES ('sl5', 4, 'brown', 1.0 , 'm'); INSERT INTO shoelace_data VALUES ('sl6', 0, 'brown', 0.9 , 'm'); INSERT INTO shoelace_data VALUES ('sl7', 7, 'brown', 60 , 'cm'); INSERT INTO shoelace_data VALUES ('sl8', 1, 'brown', 40 , 'inch'); -- SELECTs in doc SELECT * FROM shoelace ORDER BY sl_name; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl1 | 5 | black | 80 | cm | 80 sl2 | 6 | black | 100 | cm | 100 sl3 | 0 | black | 35 | inch | 88.9 sl4 | 8 | black | 40 | inch | 101.6 sl5 | 4 | brown | 1 | m | 100 sl6 | 0 | brown | 0.9 | m | 90 sl7 | 7 | brown | 60 | cm | 60 sl8 | 1 | brown | 40 | inch | 101.6 (8 rows) SELECT * FROM shoe_ready WHERE total_avail >= 2 ORDER BY 1; shoename | sh_avail | sl_name | sl_avail | total_avail ------------+----------+------------+----------+------------- sh1 | 2 | sl1 | 5 | 2 sh3 | 4 | sl7 | 7 | 4 (2 rows) CREATE TABLE shoelace_log ( sl_name char(10), -- shoelace changed sl_avail integer, -- new available value log_who name, -- who did it log_when timestamp -- when ); -- Want "log_who" to be CURRENT_USER, -- but that is non-portable for the regression test -- - thomas 1999-02-21 CREATE RULE log_shoelace AS ON UPDATE TO shoelace_data WHERE NEW.sl_avail != OLD.sl_avail DO INSERT INTO shoelace_log VALUES ( NEW.sl_name, NEW.sl_avail, 'Al Bundy', 'epoch' ); UPDATE shoelace_data SET sl_avail = 6 WHERE sl_name = 'sl7'; SELECT * FROM shoelace_log; sl_name | sl_avail | log_who | log_when ------------+----------+----------+-------------------------- sl7 | 6 | Al Bundy | Thu Jan 01 00:00:00 1970 (1 row) CREATE RULE shoelace_ins AS ON INSERT TO shoelace DO INSTEAD INSERT INTO shoelace_data VALUES ( NEW.sl_name, NEW.sl_avail, NEW.sl_color, NEW.sl_len, NEW.sl_unit); CREATE RULE shoelace_upd AS ON UPDATE TO shoelace DO INSTEAD UPDATE shoelace_data SET sl_name = NEW.sl_name, sl_avail = NEW.sl_avail, sl_color = NEW.sl_color, sl_len = NEW.sl_len, sl_unit = NEW.sl_unit WHERE sl_name = OLD.sl_name; CREATE RULE shoelace_del AS ON DELETE TO shoelace DO INSTEAD DELETE FROM shoelace_data WHERE sl_name = OLD.sl_name; CREATE TABLE shoelace_arrive ( arr_name char(10), arr_quant integer ); CREATE TABLE shoelace_ok ( ok_name char(10), ok_quant integer ); CREATE RULE shoelace_ok_ins AS ON INSERT TO shoelace_ok DO INSTEAD UPDATE shoelace SET sl_avail = sl_avail + NEW.ok_quant WHERE sl_name = NEW.ok_name; INSERT INTO shoelace_arrive VALUES ('sl3', 10); INSERT INTO shoelace_arrive VALUES ('sl6', 20); INSERT INTO shoelace_arrive VALUES ('sl8', 20); SELECT * FROM shoelace ORDER BY sl_name; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl1 | 5 | black | 80 | cm | 80 sl2 | 6 | black | 100 | cm | 100 sl3 | 0 | black | 35 | inch | 88.9 sl4 | 8 | black | 40 | inch | 101.6 sl5 | 4 | brown | 1 | m | 100 sl6 | 0 | brown | 0.9 | m | 90 sl7 | 6 | brown | 60 | cm | 60 sl8 | 1 | brown | 40 | inch | 101.6 (8 rows) insert into shoelace_ok select * from shoelace_arrive; SELECT * FROM shoelace ORDER BY sl_name; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl1 | 5 | black | 80 | cm | 80 sl2 | 6 | black | 100 | cm | 100 sl3 | 10 | black | 35 | inch | 88.9 sl4 | 8 | black | 40 | inch | 101.6 sl5 | 4 | brown | 1 | m | 100 sl6 | 20 | brown | 0.9 | m | 90 sl7 | 6 | brown | 60 | cm | 60 sl8 | 21 | brown | 40 | inch | 101.6 (8 rows) SELECT * FROM shoelace_log ORDER BY sl_name; sl_name | sl_avail | log_who | log_when ------------+----------+----------+-------------------------- sl3 | 10 | Al Bundy | Thu Jan 01 00:00:00 1970 sl6 | 20 | Al Bundy | Thu Jan 01 00:00:00 1970 sl7 | 6 | Al Bundy | Thu Jan 01 00:00:00 1970 sl8 | 21 | Al Bundy | Thu Jan 01 00:00:00 1970 (4 rows) CREATE VIEW shoelace_obsolete AS SELECT * FROM shoelace WHERE NOT EXISTS (SELECT shoename FROM shoe WHERE slcolor = sl_color); CREATE VIEW shoelace_candelete AS SELECT * FROM shoelace_obsolete WHERE sl_avail = 0; insert into shoelace values ('sl9', 0, 'pink', 35.0, 'inch', 0.0); insert into shoelace values ('sl10', 1000, 'magenta', 40.0, 'inch', 0.0); -- Unsupported (even though a similar updatable view construct is) insert into shoelace values ('sl10', 1000, 'magenta', 40.0, 'inch', 0.0) on conflict do nothing; ERROR: INSERT with ON CONFLICT clause cannot be used with table that has INSERT or UPDATE rules SELECT * FROM shoelace_obsolete ORDER BY sl_len_cm; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl9 | 0 | pink | 35 | inch | 88.9 sl10 | 1000 | magenta | 40 | inch | 101.6 (2 rows) SELECT * FROM shoelace_candelete; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl9 | 0 | pink | 35 | inch | 88.9 (1 row) DELETE FROM shoelace WHERE EXISTS (SELECT * FROM shoelace_candelete WHERE sl_name = shoelace.sl_name); SELECT * FROM shoelace ORDER BY sl_name; sl_name | sl_avail | sl_color | sl_len | sl_unit | sl_len_cm ------------+----------+------------+--------+----------+----------- sl1 | 5 | black | 80 | cm | 80 sl10 | 1000 | magenta | 40 | inch | 101.6 sl2 | 6 | black | 100 | cm | 100 sl3 | 10 | black | 35 | inch | 88.9 sl4 | 8 | black | 40 | inch | 101.6 sl5 | 4 | brown | 1 | m | 100 sl6 | 20 | brown | 0.9 | m | 90 sl7 | 6 | brown | 60 | cm | 60 sl8 | 21 | brown | 40 | inch | 101.6 (9 rows) SELECT * FROM shoe ORDER BY shoename; shoename | sh_avail | slcolor | slminlen | slminlen_cm | slmaxlen | slmaxlen_cm | slunit ------------+----------+------------+----------+-------------+----------+-------------+---------- sh1 | 2 | black | 70 | 70 | 90 | 90 | cm sh2 | 0 | black | 30 | 76.2 | 40 | 101.6 | inch sh3 | 4 | brown | 50 | 50 | 65 | 65 | cm sh4 | 3 | brown | 40 | 101.6 | 50 | 127 | inch (4 rows) SELECT count(*) FROM shoe; count ------- 4 (1 row) -- -- Simple test of qualified ON INSERT ... this did not work in 7.0 ... -- create table rules_foo (f1 int); create table rules_foo2 (f1 int); create rule rules_foorule as on insert to rules_foo where f1 < 100 do instead nothing; insert into rules_foo values(1); insert into rules_foo values(1001); select * from rules_foo; f1 ------ 1001 (1 row) drop rule rules_foorule on rules_foo; -- this should fail because f1 is not exposed for unqualified reference: create rule rules_foorule as on insert to rules_foo where f1 < 100 do instead insert into rules_foo2 values (f1); ERROR: column "f1" does not exist LINE 2: do instead insert into rules_foo2 values (f1); ^ DETAIL: There are columns named "f1", but they are in tables that cannot be referenced from this part of the query. HINT: Try using a table-qualified name. -- this is the correct way: create rule rules_foorule as on insert to rules_foo where f1 < 100 do instead insert into rules_foo2 values (new.f1); insert into rules_foo values(2); insert into rules_foo values(100); select * from rules_foo; f1 ------ 1001 100 (2 rows) select * from rules_foo2; f1 ---- 2 (1 row) drop rule rules_foorule on rules_foo; drop table rules_foo; drop table rules_foo2; -- -- Test rules containing INSERT ... SELECT, which is a very ugly special -- case as of 7.1. Example is based on bug report from Joel Burton. -- create table pparent (pid int, txt text); insert into pparent values (1,'parent1'); insert into pparent values (2,'parent2'); create table cchild (pid int, descrip text); insert into cchild values (1,'descrip1'); create view vview as select pparent.pid, txt, descrip from pparent left join cchild using (pid); create rule rrule as on update to vview do instead ( insert into cchild (pid, descrip) select old.pid, new.descrip where old.descrip isnull; update cchild set descrip = new.descrip where cchild.pid = old.pid; ); select * from vview; pid | txt | descrip -----+---------+---------- 1 | parent1 | descrip1 2 | parent2 | (2 rows) update vview set descrip='test1' where pid=1; select * from vview; pid | txt | descrip -----+---------+--------- 1 | parent1 | test1 2 | parent2 | (2 rows) update vview set descrip='test2' where pid=2; select * from vview; pid | txt | descrip -----+---------+--------- 1 | parent1 | test1 2 | parent2 | test2 (2 rows) update vview set descrip='test3' where pid=3; select * from vview; pid | txt | descrip -----+---------+--------- 1 | parent1 | test1 2 | parent2 | test2 (2 rows) select * from cchild; pid | descrip -----+--------- 1 | test1 2 | test2 (2 rows) drop rule rrule on vview; drop view vview; drop table pparent; drop table cchild; -- -- Check that ruleutils are working -- -- temporarily disable fancy output, so view changes create less diff noise \a\t SELECT viewname, definition FROM pg_views WHERE schemaname = 'pg_catalog' ORDER BY viewname; pg_available_extension_versions| SELECT e.name, e.version, (x.extname IS NOT NULL) AS installed, e.superuser, e.trusted, e.relocatable, e.schema, e.requires, e.comment FROM (pg_available_extension_versions() e(name, version, superuser, trusted, relocatable, schema, requires, comment) LEFT JOIN pg_extension x ON (((e.name = x.extname) AND (e.version = x.extversion)))); pg_available_extensions| SELECT e.name, e.default_version, x.extversion AS installed_version, e.comment FROM (pg_available_extensions() e(name, default_version, comment) LEFT JOIN pg_extension x ON ((e.name = x.extname))); pg_backend_memory_contexts| SELECT name, ident, parent, level, total_bytes, total_nblocks, free_bytes, free_chunks, used_bytes FROM pg_get_backend_memory_contexts() pg_get_backend_memory_contexts(name, ident, parent, level, total_bytes, total_nblocks, free_bytes, free_chunks, used_bytes); pg_config| SELECT name, setting FROM pg_config() pg_config(name, setting); pg_cursors| SELECT name, statement, is_holdable, is_binary, is_scrollable, creation_time FROM pg_cursor() c(name, statement, is_holdable, is_binary, is_scrollable, creation_time); pg_file_settings| SELECT sourcefile, sourceline, seqno, name, setting, applied, error FROM pg_show_all_file_settings() a(sourcefile, sourceline, seqno, name, setting, applied, error); pg_group| SELECT rolname AS groname, oid AS grosysid, ARRAY( SELECT pg_auth_members.member FROM pg_auth_members WHERE (pg_auth_members.roleid = pg_authid.oid)) AS grolist FROM pg_authid WHERE (NOT rolcanlogin); pg_hba_file_rules| SELECT rule_number, file_name, line_number, type, database, user_name, address, netmask, auth_method, options, error FROM pg_hba_file_rules() a(rule_number, file_name, line_number, type, database, user_name, address, netmask, auth_method, options, error); pg_ident_file_mappings| SELECT map_number, file_name, line_number, map_name, sys_name, pg_username, error FROM pg_ident_file_mappings() a(map_number, file_name, line_number, map_name, sys_name, pg_username, error); pg_indexes| SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, t.spcname AS tablespace, pg_get_indexdef(i.oid) AS indexdef FROM ((((pg_index x JOIN pg_class c ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = i.reltablespace))) WHERE ((c.relkind = ANY (ARRAY['r'::"char", 'm'::"char", 'p'::"char"])) AND (i.relkind = ANY (ARRAY['i'::"char", 'I'::"char"]))); pg_locks| SELECT locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath, waitstart FROM pg_lock_status() l(locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath, waitstart); pg_matviews| SELECT n.nspname AS schemaname, c.relname AS matviewname, pg_get_userbyid(c.relowner) AS matviewowner, t.spcname AS tablespace, c.relhasindex AS hasindexes, c.relispopulated AS ispopulated, pg_get_viewdef(c.oid) AS definition FROM ((pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = c.reltablespace))) WHERE (c.relkind = 'm'::"char"); pg_policies| SELECT n.nspname AS schemaname, c.relname AS tablename, pol.polname AS policyname, CASE WHEN pol.polpermissive THEN 'PERMISSIVE'::text ELSE 'RESTRICTIVE'::text END AS permissive, CASE WHEN (pol.polroles = '{0}'::oid[]) THEN (string_to_array('public'::text, ''::text))::name[] ELSE ARRAY( SELECT pg_authid.rolname FROM pg_authid WHERE (pg_authid.oid = ANY (pol.polroles)) ORDER BY pg_authid.rolname) END AS roles, CASE pol.polcmd WHEN 'r'::"char" THEN 'SELECT'::text WHEN 'a'::"char" THEN 'INSERT'::text WHEN 'w'::"char" THEN 'UPDATE'::text WHEN 'd'::"char" THEN 'DELETE'::text WHEN '*'::"char" THEN 'ALL'::text ELSE NULL::text END AS cmd, pg_get_expr(pol.polqual, pol.polrelid) AS qual, pg_get_expr(pol.polwithcheck, pol.polrelid) AS with_check FROM ((pg_policy pol JOIN pg_class c ON ((c.oid = pol.polrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))); pg_prepared_statements| SELECT name, statement, prepare_time, parameter_types, result_types, from_sql, generic_plans, custom_plans FROM pg_prepared_statement() p(name, statement, prepare_time, parameter_types, result_types, from_sql, generic_plans, custom_plans); pg_prepared_xacts| SELECT p.transaction, p.gid, p.prepared, u.rolname AS owner, d.datname AS database FROM ((pg_prepared_xact() p(transaction, gid, prepared, ownerid, dbid) LEFT JOIN pg_authid u ON ((p.ownerid = u.oid))) LEFT JOIN pg_database d ON ((p.dbid = d.oid))); pg_publication_tables| SELECT p.pubname, n.nspname AS schemaname, c.relname AS tablename, ( SELECT array_agg(a.attname ORDER BY a.attnum) AS array_agg FROM pg_attribute a WHERE ((a.attrelid = gpt.relid) AND (a.attnum = ANY ((gpt.attrs)::smallint[])))) AS attnames, pg_get_expr(gpt.qual, gpt.relid) AS rowfilter FROM pg_publication p, LATERAL pg_get_publication_tables(VARIADIC ARRAY[(p.pubname)::text]) gpt(pubid, relid, attrs, qual), (pg_class c JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.oid = gpt.relid); pg_replication_origin_status| SELECT local_id, external_id, remote_lsn, local_lsn FROM pg_show_replication_origin_status() pg_show_replication_origin_status(local_id, external_id, remote_lsn, local_lsn); pg_replication_slots| SELECT l.slot_name, l.plugin, l.slot_type, l.datoid, d.datname AS database, l.temporary, l.active, l.active_pid, l.xmin, l.catalog_xmin, l.restart_lsn, l.confirmed_flush_lsn, l.wal_status, l.safe_wal_size, l.two_phase, l.last_inactive_time, l.conflicting, l.invalidation_reason, l.failover, l.synced FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status, safe_wal_size, two_phase, last_inactive_time, conflicting, invalidation_reason, failover, synced) LEFT JOIN pg_database d ON ((l.datoid = d.oid))); pg_roles| SELECT pg_authid.rolname, pg_authid.rolsuper, pg_authid.rolinherit, pg_authid.rolcreaterole, pg_authid.rolcreatedb, pg_authid.rolcanlogin, pg_authid.rolreplication, pg_authid.rolconnlimit, '********'::text AS rolpassword, pg_authid.rolvaliduntil, pg_authid.rolbypassrls, s.setconfig AS rolconfig, pg_authid.oid FROM (pg_authid LEFT JOIN pg_db_role_setting s ON (((pg_authid.oid = s.setrole) AND (s.setdatabase = (0)::oid)))); pg_rules| SELECT n.nspname AS schemaname, c.relname AS tablename, r.rulename, pg_get_ruledef(r.oid) AS definition FROM ((pg_rewrite r JOIN pg_class c ON ((c.oid = r.ev_class))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (r.rulename <> '_RETURN'::name); pg_seclabels| SELECT l.objoid, l.classoid, l.objsubid, CASE WHEN (rel.relkind = ANY (ARRAY['r'::"char", 'p'::"char"])) THEN 'table'::text WHEN (rel.relkind = 'v'::"char") THEN 'view'::text WHEN (rel.relkind = 'm'::"char") THEN 'materialized view'::text WHEN (rel.relkind = 'S'::"char") THEN 'sequence'::text WHEN (rel.relkind = 'f'::"char") THEN 'foreign table'::text ELSE NULL::text END AS objtype, rel.relnamespace AS objnamespace, CASE WHEN pg_table_is_visible(rel.oid) THEN quote_ident((rel.relname)::text) ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((rel.relname)::text)) END AS objname, l.provider, l.label FROM ((pg_seclabel l JOIN pg_class rel ON (((l.classoid = rel.tableoid) AND (l.objoid = rel.oid)))) JOIN pg_namespace nsp ON ((rel.relnamespace = nsp.oid))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'column'::text AS objtype, rel.relnamespace AS objnamespace, (( CASE WHEN pg_table_is_visible(rel.oid) THEN quote_ident((rel.relname)::text) ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((rel.relname)::text)) END || '.'::text) || (att.attname)::text) AS objname, l.provider, l.label FROM (((pg_seclabel l JOIN pg_class rel ON (((l.classoid = rel.tableoid) AND (l.objoid = rel.oid)))) JOIN pg_attribute att ON (((rel.oid = att.attrelid) AND (l.objsubid = att.attnum)))) JOIN pg_namespace nsp ON ((rel.relnamespace = nsp.oid))) WHERE (l.objsubid <> 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, CASE pro.prokind WHEN 'a'::"char" THEN 'aggregate'::text WHEN 'f'::"char" THEN 'function'::text WHEN 'p'::"char" THEN 'procedure'::text WHEN 'w'::"char" THEN 'window'::text ELSE NULL::text END AS objtype, pro.pronamespace AS objnamespace, ((( CASE WHEN pg_function_is_visible(pro.oid) THEN quote_ident((pro.proname)::text) ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((pro.proname)::text)) END || '('::text) || pg_get_function_arguments(pro.oid)) || ')'::text) AS objname, l.provider, l.label FROM ((pg_seclabel l JOIN pg_proc pro ON (((l.classoid = pro.tableoid) AND (l.objoid = pro.oid)))) JOIN pg_namespace nsp ON ((pro.pronamespace = nsp.oid))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, CASE WHEN (typ.typtype = 'd'::"char") THEN 'domain'::text ELSE 'type'::text END AS objtype, typ.typnamespace AS objnamespace, CASE WHEN pg_type_is_visible(typ.oid) THEN quote_ident((typ.typname)::text) ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((typ.typname)::text)) END AS objname, l.provider, l.label FROM ((pg_seclabel l JOIN pg_type typ ON (((l.classoid = typ.tableoid) AND (l.objoid = typ.oid)))) JOIN pg_namespace nsp ON ((typ.typnamespace = nsp.oid))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'large object'::text AS objtype, NULL::oid AS objnamespace, (l.objoid)::text AS objname, l.provider, l.label FROM (pg_seclabel l JOIN pg_largeobject_metadata lom ON ((l.objoid = lom.oid))) WHERE ((l.classoid = ('pg_largeobject'::regclass)::oid) AND (l.objsubid = 0)) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'language'::text AS objtype, NULL::oid AS objnamespace, quote_ident((lan.lanname)::text) AS objname, l.provider, l.label FROM (pg_seclabel l JOIN pg_language lan ON (((l.classoid = lan.tableoid) AND (l.objoid = lan.oid)))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'schema'::text AS objtype, nsp.oid AS objnamespace, quote_ident((nsp.nspname)::text) AS objname, l.provider, l.label FROM (pg_seclabel l JOIN pg_namespace nsp ON (((l.classoid = nsp.tableoid) AND (l.objoid = nsp.oid)))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'event trigger'::text AS objtype, NULL::oid AS objnamespace, quote_ident((evt.evtname)::text) AS objname, l.provider, l.label FROM (pg_seclabel l JOIN pg_event_trigger evt ON (((l.classoid = evt.tableoid) AND (l.objoid = evt.oid)))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, l.objsubid, 'publication'::text AS objtype, NULL::oid AS objnamespace, quote_ident((p.pubname)::text) AS objname, l.provider, l.label FROM (pg_seclabel l JOIN pg_publication p ON (((l.classoid = p.tableoid) AND (l.objoid = p.oid)))) WHERE (l.objsubid = 0) UNION ALL SELECT l.objoid, l.classoid, 0 AS objsubid, 'subscription'::text AS objtype, NULL::oid AS objnamespace, quote_ident((s.subname)::text) AS objname, l.provider, l.label FROM (pg_shseclabel l JOIN pg_subscription s ON (((l.classoid = s.tableoid) AND (l.objoid = s.oid)))) UNION ALL SELECT l.objoid, l.classoid, 0 AS objsubid, 'database'::text AS objtype, NULL::oid AS objnamespace, quote_ident((dat.datname)::text) AS objname, l.provider, l.label FROM (pg_shseclabel l JOIN pg_database dat ON (((l.classoid = dat.tableoid) AND (l.objoid = dat.oid)))) UNION ALL SELECT l.objoid, l.classoid, 0 AS objsubid, 'tablespace'::text AS objtype, NULL::oid AS objnamespace, quote_ident((spc.spcname)::text) AS objname, l.provider, l.label FROM (pg_shseclabel l JOIN pg_tablespace spc ON (((l.classoid = spc.tableoid) AND (l.objoid = spc.oid)))) UNION ALL SELECT l.objoid, l.classoid, 0 AS objsubid, 'role'::text AS objtype, NULL::oid AS objnamespace, quote_ident((rol.rolname)::text) AS objname, l.provider, l.label FROM (pg_shseclabel l JOIN pg_authid rol ON (((l.classoid = rol.tableoid) AND (l.objoid = rol.oid)))); pg_sequences| SELECT n.nspname AS schemaname, c.relname AS sequencename, pg_get_userbyid(c.relowner) AS sequenceowner, (s.seqtypid)::regtype AS data_type, s.seqstart AS start_value, s.seqmin AS min_value, s.seqmax AS max_value, s.seqincrement AS increment_by, s.seqcycle AS cycle, s.seqcache AS cache_size, CASE WHEN has_sequence_privilege(c.oid, 'SELECT,USAGE'::text) THEN pg_sequence_last_value((c.oid)::regclass) ELSE NULL::bigint END AS last_value FROM ((pg_sequence s JOIN pg_class c ON ((c.oid = s.seqrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE ((NOT pg_is_other_temp_schema(n.oid)) AND (c.relkind = 'S'::"char")); pg_settings| SELECT name, setting, unit, category, short_desc, extra_desc, context, vartype, source, min_val, max_val, enumvals, boot_val, reset_val, sourcefile, sourceline, pending_restart FROM pg_show_all_settings() a(name, setting, unit, category, short_desc, extra_desc, context, vartype, source, min_val, max_val, enumvals, boot_val, reset_val, sourcefile, sourceline, pending_restart); pg_shadow| SELECT pg_authid.rolname AS usename, pg_authid.oid AS usesysid, pg_authid.rolcreatedb AS usecreatedb, pg_authid.rolsuper AS usesuper, pg_authid.rolreplication AS userepl, pg_authid.rolbypassrls AS usebypassrls, pg_authid.rolpassword AS passwd, pg_authid.rolvaliduntil AS valuntil, s.setconfig AS useconfig FROM (pg_authid LEFT JOIN pg_db_role_setting s ON (((pg_authid.oid = s.setrole) AND (s.setdatabase = (0)::oid)))) WHERE pg_authid.rolcanlogin; pg_shmem_allocations| SELECT name, off, size, allocated_size FROM pg_get_shmem_allocations() pg_get_shmem_allocations(name, off, size, allocated_size); pg_stat_activity| SELECT s.datid, d.datname, s.pid, s.leader_pid, s.usesysid, u.rolname AS usename, s.application_name, s.client_addr, s.client_hostname, s.client_port, s.backend_start, s.xact_start, s.query_start, s.state_change, s.wait_event_type, s.wait_event, s.state, s.backend_xid, s.backend_xmin, s.query_id, s.query, s.backend_type FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id) LEFT JOIN pg_database d ON ((s.datid = d.oid))) LEFT JOIN pg_authid u ON ((s.usesysid = u.oid))); pg_stat_all_indexes| SELECT c.oid AS relid, i.oid AS indexrelid, n.nspname AS schemaname, c.relname, i.relname AS indexrelname, pg_stat_get_numscans(i.oid) AS idx_scan, pg_stat_get_lastscan(i.oid) AS last_idx_scan, pg_stat_get_tuples_returned(i.oid) AS idx_tup_read, pg_stat_get_tuples_fetched(i.oid) AS idx_tup_fetch FROM (((pg_class c JOIN pg_index x ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char"])); pg_stat_all_tables| SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, pg_stat_get_numscans(c.oid) AS seq_scan, pg_stat_get_lastscan(c.oid) AS last_seq_scan, pg_stat_get_tuples_returned(c.oid) AS seq_tup_read, (sum(pg_stat_get_numscans(i.indexrelid)))::bigint AS idx_scan, max(pg_stat_get_lastscan(i.indexrelid)) AS last_idx_scan, ((sum(pg_stat_get_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_tuples_fetched(c.oid)) AS idx_tup_fetch, pg_stat_get_tuples_inserted(c.oid) AS n_tup_ins, pg_stat_get_tuples_updated(c.oid) AS n_tup_upd, pg_stat_get_tuples_deleted(c.oid) AS n_tup_del, pg_stat_get_tuples_hot_updated(c.oid) AS n_tup_hot_upd, pg_stat_get_tuples_newpage_updated(c.oid) AS n_tup_newpage_upd, pg_stat_get_live_tuples(c.oid) AS n_live_tup, pg_stat_get_dead_tuples(c.oid) AS n_dead_tup, pg_stat_get_mod_since_analyze(c.oid) AS n_mod_since_analyze, pg_stat_get_ins_since_vacuum(c.oid) AS n_ins_since_vacuum, pg_stat_get_last_vacuum_time(c.oid) AS last_vacuum, pg_stat_get_last_autovacuum_time(c.oid) AS last_autovacuum, pg_stat_get_last_analyze_time(c.oid) AS last_analyze, pg_stat_get_last_autoanalyze_time(c.oid) AS last_autoanalyze, pg_stat_get_vacuum_count(c.oid) AS vacuum_count, pg_stat_get_autovacuum_count(c.oid) AS autovacuum_count, pg_stat_get_analyze_count(c.oid) AS analyze_count, pg_stat_get_autoanalyze_count(c.oid) AS autoanalyze_count FROM ((pg_class c LEFT JOIN pg_index i ON ((c.oid = i.indrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char", 'p'::"char"])) GROUP BY c.oid, n.nspname, c.relname; pg_stat_archiver| SELECT archived_count, last_archived_wal, last_archived_time, failed_count, last_failed_wal, last_failed_time, stats_reset FROM pg_stat_get_archiver() s(archived_count, last_archived_wal, last_archived_time, failed_count, last_failed_wal, last_failed_time, stats_reset); pg_stat_bgwriter| SELECT pg_stat_get_bgwriter_buf_written_clean() AS buffers_clean, pg_stat_get_bgwriter_maxwritten_clean() AS maxwritten_clean, pg_stat_get_buf_alloc() AS buffers_alloc, pg_stat_get_bgwriter_stat_reset_time() AS stats_reset; pg_stat_checkpointer| SELECT pg_stat_get_checkpointer_num_timed() AS num_timed, pg_stat_get_checkpointer_num_requested() AS num_requested, pg_stat_get_checkpointer_restartpoints_timed() AS restartpoints_timed, pg_stat_get_checkpointer_restartpoints_requested() AS restartpoints_req, pg_stat_get_checkpointer_restartpoints_performed() AS restartpoints_done, pg_stat_get_checkpointer_write_time() AS write_time, pg_stat_get_checkpointer_sync_time() AS sync_time, pg_stat_get_checkpointer_buffers_written() AS buffers_written, pg_stat_get_checkpointer_stat_reset_time() AS stats_reset; pg_stat_database| SELECT oid AS datid, datname, CASE WHEN (oid = (0)::oid) THEN 0 ELSE pg_stat_get_db_numbackends(oid) END AS numbackends, pg_stat_get_db_xact_commit(oid) AS xact_commit, pg_stat_get_db_xact_rollback(oid) AS xact_rollback, (pg_stat_get_db_blocks_fetched(oid) - pg_stat_get_db_blocks_hit(oid)) AS blks_read, pg_stat_get_db_blocks_hit(oid) AS blks_hit, pg_stat_get_db_tuples_returned(oid) AS tup_returned, pg_stat_get_db_tuples_fetched(oid) AS tup_fetched, pg_stat_get_db_tuples_inserted(oid) AS tup_inserted, pg_stat_get_db_tuples_updated(oid) AS tup_updated, pg_stat_get_db_tuples_deleted(oid) AS tup_deleted, pg_stat_get_db_conflict_all(oid) AS conflicts, pg_stat_get_db_temp_files(oid) AS temp_files, pg_stat_get_db_temp_bytes(oid) AS temp_bytes, pg_stat_get_db_deadlocks(oid) AS deadlocks, pg_stat_get_db_checksum_failures(oid) AS checksum_failures, pg_stat_get_db_checksum_last_failure(oid) AS checksum_last_failure, pg_stat_get_db_blk_read_time(oid) AS blk_read_time, pg_stat_get_db_blk_write_time(oid) AS blk_write_time, pg_stat_get_db_session_time(oid) AS session_time, pg_stat_get_db_active_time(oid) AS active_time, pg_stat_get_db_idle_in_transaction_time(oid) AS idle_in_transaction_time, pg_stat_get_db_sessions(oid) AS sessions, pg_stat_get_db_sessions_abandoned(oid) AS sessions_abandoned, pg_stat_get_db_sessions_fatal(oid) AS sessions_fatal, pg_stat_get_db_sessions_killed(oid) AS sessions_killed, pg_stat_get_db_stat_reset_time(oid) AS stats_reset FROM ( SELECT 0 AS oid, NULL::name AS datname UNION ALL SELECT pg_database.oid, pg_database.datname FROM pg_database) d; pg_stat_database_conflicts| SELECT oid AS datid, datname, pg_stat_get_db_conflict_tablespace(oid) AS confl_tablespace, pg_stat_get_db_conflict_lock(oid) AS confl_lock, pg_stat_get_db_conflict_snapshot(oid) AS confl_snapshot, pg_stat_get_db_conflict_bufferpin(oid) AS confl_bufferpin, pg_stat_get_db_conflict_startup_deadlock(oid) AS confl_deadlock, pg_stat_get_db_conflict_logicalslot(oid) AS confl_active_logicalslot FROM pg_database d; pg_stat_gssapi| SELECT pid, gss_auth AS gss_authenticated, gss_princ AS principal, gss_enc AS encrypted, gss_delegation AS credentials_delegated FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id) WHERE (client_port IS NOT NULL); pg_stat_io| SELECT backend_type, object, context, reads, read_time, writes, write_time, writebacks, writeback_time, extends, extend_time, op_bytes, hits, evictions, reuses, fsyncs, fsync_time, stats_reset FROM pg_stat_get_io() b(backend_type, object, context, reads, read_time, writes, write_time, writebacks, writeback_time, extends, extend_time, op_bytes, hits, evictions, reuses, fsyncs, fsync_time, stats_reset); pg_stat_progress_analyze| SELECT s.pid, s.datid, d.datname, s.relid, CASE s.param1 WHEN 0 THEN 'initializing'::text WHEN 1 THEN 'acquiring sample rows'::text WHEN 2 THEN 'acquiring inherited sample rows'::text WHEN 3 THEN 'computing statistics'::text WHEN 4 THEN 'computing extended statistics'::text WHEN 5 THEN 'finalizing analyze'::text ELSE NULL::text END AS phase, s.param2 AS sample_blks_total, s.param3 AS sample_blks_scanned, s.param4 AS ext_stats_total, s.param5 AS ext_stats_computed, s.param6 AS child_tables_total, s.param7 AS child_tables_done, (s.param8)::oid AS current_child_table_relid FROM (pg_stat_get_progress_info('ANALYZE'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_progress_basebackup| SELECT pid, CASE param1 WHEN 0 THEN 'initializing'::text WHEN 1 THEN 'waiting for checkpoint to finish'::text WHEN 2 THEN 'estimating backup size'::text WHEN 3 THEN 'streaming database files'::text WHEN 4 THEN 'waiting for wal archiving to finish'::text WHEN 5 THEN 'transferring wal files'::text ELSE NULL::text END AS phase, CASE param2 WHEN '-1'::integer THEN NULL::bigint ELSE param2 END AS backup_total, param3 AS backup_streamed, param4 AS tablespaces_total, param5 AS tablespaces_streamed FROM pg_stat_get_progress_info('BASEBACKUP'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20); pg_stat_progress_cluster| SELECT s.pid, s.datid, d.datname, s.relid, CASE s.param1 WHEN 1 THEN 'CLUSTER'::text WHEN 2 THEN 'VACUUM FULL'::text ELSE NULL::text END AS command, CASE s.param2 WHEN 0 THEN 'initializing'::text WHEN 1 THEN 'seq scanning heap'::text WHEN 2 THEN 'index scanning heap'::text WHEN 3 THEN 'sorting tuples'::text WHEN 4 THEN 'writing new heap'::text WHEN 5 THEN 'swapping relation files'::text WHEN 6 THEN 'rebuilding index'::text WHEN 7 THEN 'performing final cleanup'::text ELSE NULL::text END AS phase, (s.param3)::oid AS cluster_index_relid, s.param4 AS heap_tuples_scanned, s.param5 AS heap_tuples_written, s.param6 AS heap_blks_total, s.param7 AS heap_blks_scanned, s.param8 AS index_rebuild_count FROM (pg_stat_get_progress_info('CLUSTER'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_progress_copy| SELECT s.pid, s.datid, d.datname, s.relid, CASE s.param5 WHEN 1 THEN 'COPY FROM'::text WHEN 2 THEN 'COPY TO'::text ELSE NULL::text END AS command, CASE s.param6 WHEN 1 THEN 'FILE'::text WHEN 2 THEN 'PROGRAM'::text WHEN 3 THEN 'PIPE'::text WHEN 4 THEN 'CALLBACK'::text ELSE NULL::text END AS type, s.param1 AS bytes_processed, s.param2 AS bytes_total, s.param3 AS tuples_processed, s.param4 AS tuples_excluded, s.param7 AS tuples_skipped FROM (pg_stat_get_progress_info('COPY'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_progress_create_index| SELECT s.pid, s.datid, d.datname, s.relid, (s.param7)::oid AS index_relid, CASE s.param1 WHEN 1 THEN 'CREATE INDEX'::text WHEN 2 THEN 'CREATE INDEX CONCURRENTLY'::text WHEN 3 THEN 'REINDEX'::text WHEN 4 THEN 'REINDEX CONCURRENTLY'::text ELSE NULL::text END AS command, CASE s.param10 WHEN 0 THEN 'initializing'::text WHEN 1 THEN 'waiting for writers before build'::text WHEN 2 THEN ('building index'::text || COALESCE((': '::text || pg_indexam_progress_phasename((s.param9)::oid, s.param11)), ''::text)) WHEN 3 THEN 'waiting for writers before validation'::text WHEN 4 THEN 'index validation: scanning index'::text WHEN 5 THEN 'index validation: sorting tuples'::text WHEN 6 THEN 'index validation: scanning table'::text WHEN 7 THEN 'waiting for old snapshots'::text WHEN 8 THEN 'waiting for readers before marking dead'::text WHEN 9 THEN 'waiting for readers before dropping'::text ELSE NULL::text END AS phase, s.param4 AS lockers_total, s.param5 AS lockers_done, s.param6 AS current_locker_pid, s.param16 AS blocks_total, s.param17 AS blocks_done, s.param12 AS tuples_total, s.param13 AS tuples_done, s.param14 AS partitions_total, s.param15 AS partitions_done FROM (pg_stat_get_progress_info('CREATE INDEX'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_progress_vacuum| SELECT s.pid, s.datid, d.datname, s.relid, CASE s.param1 WHEN 0 THEN 'initializing'::text WHEN 1 THEN 'scanning heap'::text WHEN 2 THEN 'vacuuming indexes'::text WHEN 3 THEN 'vacuuming heap'::text WHEN 4 THEN 'cleaning up indexes'::text WHEN 5 THEN 'truncating heap'::text WHEN 6 THEN 'performing final cleanup'::text ELSE NULL::text END AS phase, s.param2 AS heap_blks_total, s.param3 AS heap_blks_scanned, s.param4 AS heap_blks_vacuumed, s.param5 AS index_vacuum_count, s.param6 AS max_dead_tuples, s.param7 AS num_dead_tuples, s.param8 AS indexes_total, s.param9 AS indexes_processed FROM (pg_stat_get_progress_info('VACUUM'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_recovery_prefetch| SELECT stats_reset, prefetch, hit, skip_init, skip_new, skip_fpw, skip_rep, wal_distance, block_distance, io_depth FROM pg_stat_get_recovery_prefetch() s(stats_reset, prefetch, hit, skip_init, skip_new, skip_fpw, skip_rep, wal_distance, block_distance, io_depth); pg_stat_replication| SELECT s.pid, s.usesysid, u.rolname AS usename, s.application_name, s.client_addr, s.client_hostname, s.client_port, s.backend_start, s.backend_xmin, w.state, w.sent_lsn, w.write_lsn, w.flush_lsn, w.replay_lsn, w.write_lag, w.flush_lag, w.replay_lag, w.sync_priority, w.sync_state, w.reply_time FROM ((pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id) JOIN pg_stat_get_wal_senders() w(pid, state, sent_lsn, write_lsn, flush_lsn, replay_lsn, write_lag, flush_lag, replay_lag, sync_priority, sync_state, reply_time) ON ((s.pid = w.pid))) LEFT JOIN pg_authid u ON ((s.usesysid = u.oid))); pg_stat_replication_slots| SELECT s.slot_name, s.spill_txns, s.spill_count, s.spill_bytes, s.stream_txns, s.stream_count, s.stream_bytes, s.total_txns, s.total_bytes, s.stats_reset FROM pg_replication_slots r, LATERAL pg_stat_get_replication_slot((r.slot_name)::text) s(slot_name, spill_txns, spill_count, spill_bytes, stream_txns, stream_count, stream_bytes, total_txns, total_bytes, stats_reset) WHERE (r.datoid IS NOT NULL); pg_stat_slru| SELECT name, blks_zeroed, blks_hit, blks_read, blks_written, blks_exists, flushes, truncates, stats_reset FROM pg_stat_get_slru() s(name, blks_zeroed, blks_hit, blks_read, blks_written, blks_exists, flushes, truncates, stats_reset); pg_stat_ssl| SELECT pid, ssl, sslversion AS version, sslcipher AS cipher, sslbits AS bits, ssl_client_dn AS client_dn, ssl_client_serial AS client_serial, ssl_issuer_dn AS issuer_dn FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, gss_delegation, leader_pid, query_id) WHERE (client_port IS NOT NULL); pg_stat_subscription| SELECT su.oid AS subid, su.subname, st.worker_type, st.pid, st.leader_pid, st.relid, st.received_lsn, st.last_msg_send_time, st.last_msg_receipt_time, st.latest_end_lsn, st.latest_end_time FROM (pg_subscription su LEFT JOIN pg_stat_get_subscription(NULL::oid) st(subid, relid, pid, leader_pid, received_lsn, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time, worker_type) ON ((st.subid = su.oid))); pg_stat_subscription_stats| SELECT ss.subid, s.subname, ss.apply_error_count, ss.sync_error_count, ss.stats_reset FROM pg_subscription s, LATERAL pg_stat_get_subscription_stats(s.oid) ss(subid, apply_error_count, sync_error_count, stats_reset); pg_stat_sys_indexes| SELECT relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, idx_tup_fetch FROM pg_stat_all_indexes WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_stat_sys_tables| SELECT relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, vacuum_count, autovacuum_count, analyze_count, autoanalyze_count FROM pg_stat_all_tables WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_stat_user_functions| SELECT p.oid AS funcid, n.nspname AS schemaname, p.proname AS funcname, pg_stat_get_function_calls(p.oid) AS calls, pg_stat_get_function_total_time(p.oid) AS total_time, pg_stat_get_function_self_time(p.oid) AS self_time FROM (pg_proc p LEFT JOIN pg_namespace n ON ((n.oid = p.pronamespace))) WHERE ((p.prolang <> (12)::oid) AND (pg_stat_get_function_calls(p.oid) IS NOT NULL)); pg_stat_user_indexes| SELECT relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, idx_tup_fetch FROM pg_stat_all_indexes WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_stat_user_tables| SELECT relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, vacuum_count, autovacuum_count, analyze_count, autoanalyze_count FROM pg_stat_all_tables WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_stat_wal| SELECT wal_records, wal_fpi, wal_bytes, wal_buffers_full, wal_write, wal_sync, wal_write_time, wal_sync_time, stats_reset FROM pg_stat_get_wal() w(wal_records, wal_fpi, wal_bytes, wal_buffers_full, wal_write, wal_sync, wal_write_time, wal_sync_time, stats_reset); pg_stat_wal_receiver| SELECT pid, status, receive_start_lsn, receive_start_tli, written_lsn, flushed_lsn, received_tli, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time, slot_name, sender_host, sender_port, conninfo FROM pg_stat_get_wal_receiver() s(pid, status, receive_start_lsn, receive_start_tli, written_lsn, flushed_lsn, received_tli, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time, slot_name, sender_host, sender_port, conninfo) WHERE (pid IS NOT NULL); pg_stat_xact_all_tables| SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, pg_stat_get_xact_numscans(c.oid) AS seq_scan, pg_stat_get_xact_tuples_returned(c.oid) AS seq_tup_read, (sum(pg_stat_get_xact_numscans(i.indexrelid)))::bigint AS idx_scan, ((sum(pg_stat_get_xact_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_xact_tuples_fetched(c.oid)) AS idx_tup_fetch, pg_stat_get_xact_tuples_inserted(c.oid) AS n_tup_ins, pg_stat_get_xact_tuples_updated(c.oid) AS n_tup_upd, pg_stat_get_xact_tuples_deleted(c.oid) AS n_tup_del, pg_stat_get_xact_tuples_hot_updated(c.oid) AS n_tup_hot_upd, pg_stat_get_xact_tuples_newpage_updated(c.oid) AS n_tup_newpage_upd FROM ((pg_class c LEFT JOIN pg_index i ON ((c.oid = i.indrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char", 'p'::"char"])) GROUP BY c.oid, n.nspname, c.relname; pg_stat_xact_sys_tables| SELECT relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd FROM pg_stat_xact_all_tables WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_stat_xact_user_functions| SELECT p.oid AS funcid, n.nspname AS schemaname, p.proname AS funcname, pg_stat_get_xact_function_calls(p.oid) AS calls, pg_stat_get_xact_function_total_time(p.oid) AS total_time, pg_stat_get_xact_function_self_time(p.oid) AS self_time FROM (pg_proc p LEFT JOIN pg_namespace n ON ((n.oid = p.pronamespace))) WHERE ((p.prolang <> (12)::oid) AND (pg_stat_get_xact_function_calls(p.oid) IS NOT NULL)); pg_stat_xact_user_tables| SELECT relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd FROM pg_stat_xact_all_tables WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_statio_all_indexes| SELECT c.oid AS relid, i.oid AS indexrelid, n.nspname AS schemaname, c.relname, i.relname AS indexrelname, (pg_stat_get_blocks_fetched(i.oid) - pg_stat_get_blocks_hit(i.oid)) AS idx_blks_read, pg_stat_get_blocks_hit(i.oid) AS idx_blks_hit FROM (((pg_class c JOIN pg_index x ON ((c.oid = x.indrelid))) JOIN pg_class i ON ((i.oid = x.indexrelid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char"])); pg_statio_all_sequences| SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, (pg_stat_get_blocks_fetched(c.oid) - pg_stat_get_blocks_hit(c.oid)) AS blks_read, pg_stat_get_blocks_hit(c.oid) AS blks_hit FROM (pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'S'::"char"); pg_statio_all_tables| SELECT c.oid AS relid, n.nspname AS schemaname, c.relname, (pg_stat_get_blocks_fetched(c.oid) - pg_stat_get_blocks_hit(c.oid)) AS heap_blks_read, pg_stat_get_blocks_hit(c.oid) AS heap_blks_hit, i.idx_blks_read, i.idx_blks_hit, (pg_stat_get_blocks_fetched(t.oid) - pg_stat_get_blocks_hit(t.oid)) AS toast_blks_read, pg_stat_get_blocks_hit(t.oid) AS toast_blks_hit, x.idx_blks_read AS tidx_blks_read, x.idx_blks_hit AS tidx_blks_hit FROM ((((pg_class c LEFT JOIN pg_class t ON ((c.reltoastrelid = t.oid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN LATERAL ( SELECT (sum((pg_stat_get_blocks_fetched(pg_index.indexrelid) - pg_stat_get_blocks_hit(pg_index.indexrelid))))::bigint AS idx_blks_read, (sum(pg_stat_get_blocks_hit(pg_index.indexrelid)))::bigint AS idx_blks_hit FROM pg_index WHERE (pg_index.indrelid = c.oid)) i ON (true)) LEFT JOIN LATERAL ( SELECT (sum((pg_stat_get_blocks_fetched(pg_index.indexrelid) - pg_stat_get_blocks_hit(pg_index.indexrelid))))::bigint AS idx_blks_read, (sum(pg_stat_get_blocks_hit(pg_index.indexrelid)))::bigint AS idx_blks_hit FROM pg_index WHERE (pg_index.indrelid = t.oid)) x ON (true)) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char"])); pg_statio_sys_indexes| SELECT relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit FROM pg_statio_all_indexes WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_statio_sys_sequences| SELECT relid, schemaname, relname, blks_read, blks_hit FROM pg_statio_all_sequences WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_statio_sys_tables| SELECT relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, toast_blks_hit, tidx_blks_read, tidx_blks_hit FROM pg_statio_all_tables WHERE ((schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (schemaname ~ '^pg_toast'::text)); pg_statio_user_indexes| SELECT relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit FROM pg_statio_all_indexes WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_statio_user_sequences| SELECT relid, schemaname, relname, blks_read, blks_hit FROM pg_statio_all_sequences WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_statio_user_tables| SELECT relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, toast_blks_hit, tidx_blks_read, tidx_blks_hit FROM pg_statio_all_tables WHERE ((schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (schemaname !~ '^pg_toast'::text)); pg_stats| SELECT n.nspname AS schemaname, c.relname AS tablename, a.attname, s.stainherit AS inherited, s.stanullfrac AS null_frac, s.stawidth AS avg_width, s.stadistinct AS n_distinct, CASE WHEN (s.stakind1 = 1) THEN s.stavalues1 WHEN (s.stakind2 = 1) THEN s.stavalues2 WHEN (s.stakind3 = 1) THEN s.stavalues3 WHEN (s.stakind4 = 1) THEN s.stavalues4 WHEN (s.stakind5 = 1) THEN s.stavalues5 ELSE NULL::anyarray END AS most_common_vals, CASE WHEN (s.stakind1 = 1) THEN s.stanumbers1 WHEN (s.stakind2 = 1) THEN s.stanumbers2 WHEN (s.stakind3 = 1) THEN s.stanumbers3 WHEN (s.stakind4 = 1) THEN s.stanumbers4 WHEN (s.stakind5 = 1) THEN s.stanumbers5 ELSE NULL::real[] END AS most_common_freqs, CASE WHEN (s.stakind1 = 2) THEN s.stavalues1 WHEN (s.stakind2 = 2) THEN s.stavalues2 WHEN (s.stakind3 = 2) THEN s.stavalues3 WHEN (s.stakind4 = 2) THEN s.stavalues4 WHEN (s.stakind5 = 2) THEN s.stavalues5 ELSE NULL::anyarray END AS histogram_bounds, CASE WHEN (s.stakind1 = 3) THEN s.stanumbers1[1] WHEN (s.stakind2 = 3) THEN s.stanumbers2[1] WHEN (s.stakind3 = 3) THEN s.stanumbers3[1] WHEN (s.stakind4 = 3) THEN s.stanumbers4[1] WHEN (s.stakind5 = 3) THEN s.stanumbers5[1] ELSE NULL::real END AS correlation, CASE WHEN (s.stakind1 = 4) THEN s.stavalues1 WHEN (s.stakind2 = 4) THEN s.stavalues2 WHEN (s.stakind3 = 4) THEN s.stavalues3 WHEN (s.stakind4 = 4) THEN s.stavalues4 WHEN (s.stakind5 = 4) THEN s.stavalues5 ELSE NULL::anyarray END AS most_common_elems, CASE WHEN (s.stakind1 = 4) THEN s.stanumbers1 WHEN (s.stakind2 = 4) THEN s.stanumbers2 WHEN (s.stakind3 = 4) THEN s.stanumbers3 WHEN (s.stakind4 = 4) THEN s.stanumbers4 WHEN (s.stakind5 = 4) THEN s.stanumbers5 ELSE NULL::real[] END AS most_common_elem_freqs, CASE WHEN (s.stakind1 = 5) THEN s.stanumbers1 WHEN (s.stakind2 = 5) THEN s.stanumbers2 WHEN (s.stakind3 = 5) THEN s.stanumbers3 WHEN (s.stakind4 = 5) THEN s.stanumbers4 WHEN (s.stakind5 = 5) THEN s.stanumbers5 ELSE NULL::real[] END AS elem_count_histogram, CASE WHEN (s.stakind1 = 6) THEN s.stavalues1 WHEN (s.stakind2 = 6) THEN s.stavalues2 WHEN (s.stakind3 = 6) THEN s.stavalues3 WHEN (s.stakind4 = 6) THEN s.stavalues4 WHEN (s.stakind5 = 6) THEN s.stavalues5 ELSE NULL::anyarray END AS range_length_histogram, CASE WHEN (s.stakind1 = 6) THEN s.stanumbers1[1] WHEN (s.stakind2 = 6) THEN s.stanumbers2[1] WHEN (s.stakind3 = 6) THEN s.stanumbers3[1] WHEN (s.stakind4 = 6) THEN s.stanumbers4[1] WHEN (s.stakind5 = 6) THEN s.stanumbers5[1] ELSE NULL::real END AS range_empty_frac, CASE WHEN (s.stakind1 = 7) THEN s.stavalues1 WHEN (s.stakind2 = 7) THEN s.stavalues2 WHEN (s.stakind3 = 7) THEN s.stavalues3 WHEN (s.stakind4 = 7) THEN s.stavalues4 WHEN (s.stakind5 = 7) THEN s.stavalues5 ELSE NULL::anyarray END AS range_bounds_histogram FROM (((pg_statistic s JOIN pg_class c ON ((c.oid = s.starelid))) JOIN pg_attribute a ON (((c.oid = a.attrelid) AND (a.attnum = s.staattnum)))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE ((NOT a.attisdropped) AND has_column_privilege(c.oid, a.attnum, 'select'::text) AND ((c.relrowsecurity = false) OR (NOT row_security_active(c.oid)))); pg_stats_ext| SELECT cn.nspname AS schemaname, c.relname AS tablename, sn.nspname AS statistics_schemaname, s.stxname AS statistics_name, pg_get_userbyid(s.stxowner) AS statistics_owner, ( SELECT array_agg(a.attname ORDER BY a.attnum) AS array_agg FROM (unnest(s.stxkeys) k(k) JOIN pg_attribute a ON (((a.attrelid = s.stxrelid) AND (a.attnum = k.k))))) AS attnames, pg_get_statisticsobjdef_expressions(s.oid) AS exprs, s.stxkind AS kinds, sd.stxdinherit AS inherited, sd.stxdndistinct AS n_distinct, sd.stxddependencies AS dependencies, m.most_common_vals, m.most_common_val_nulls, m.most_common_freqs, m.most_common_base_freqs FROM (((((pg_statistic_ext s JOIN pg_class c ON ((c.oid = s.stxrelid))) JOIN pg_statistic_ext_data sd ON ((s.oid = sd.stxoid))) LEFT JOIN pg_namespace cn ON ((cn.oid = c.relnamespace))) LEFT JOIN pg_namespace sn ON ((sn.oid = s.stxnamespace))) LEFT JOIN LATERAL ( SELECT array_agg(pg_mcv_list_items."values") AS most_common_vals, array_agg(pg_mcv_list_items.nulls) AS most_common_val_nulls, array_agg(pg_mcv_list_items.frequency) AS most_common_freqs, array_agg(pg_mcv_list_items.base_frequency) AS most_common_base_freqs FROM pg_mcv_list_items(sd.stxdmcv) pg_mcv_list_items(index, "values", nulls, frequency, base_frequency)) m ON ((sd.stxdmcv IS NOT NULL))) WHERE ((NOT (EXISTS ( SELECT 1 FROM (unnest(s.stxkeys) k(k) JOIN pg_attribute a ON (((a.attrelid = s.stxrelid) AND (a.attnum = k.k)))) WHERE (NOT has_column_privilege(c.oid, a.attnum, 'select'::text))))) AND ((c.relrowsecurity = false) OR (NOT row_security_active(c.oid)))); pg_stats_ext_exprs| SELECT cn.nspname AS schemaname, c.relname AS tablename, sn.nspname AS statistics_schemaname, s.stxname AS statistics_name, pg_get_userbyid(s.stxowner) AS statistics_owner, stat.expr, sd.stxdinherit AS inherited, (stat.a).stanullfrac AS null_frac, (stat.a).stawidth AS avg_width, (stat.a).stadistinct AS n_distinct, CASE WHEN ((stat.a).stakind1 = 1) THEN (stat.a).stavalues1 WHEN ((stat.a).stakind2 = 1) THEN (stat.a).stavalues2 WHEN ((stat.a).stakind3 = 1) THEN (stat.a).stavalues3 WHEN ((stat.a).stakind4 = 1) THEN (stat.a).stavalues4 WHEN ((stat.a).stakind5 = 1) THEN (stat.a).stavalues5 ELSE NULL::anyarray END AS most_common_vals, CASE WHEN ((stat.a).stakind1 = 1) THEN (stat.a).stanumbers1 WHEN ((stat.a).stakind2 = 1) THEN (stat.a).stanumbers2 WHEN ((stat.a).stakind3 = 1) THEN (stat.a).stanumbers3 WHEN ((stat.a).stakind4 = 1) THEN (stat.a).stanumbers4 WHEN ((stat.a).stakind5 = 1) THEN (stat.a).stanumbers5 ELSE NULL::real[] END AS most_common_freqs, CASE WHEN ((stat.a).stakind1 = 2) THEN (stat.a).stavalues1 WHEN ((stat.a).stakind2 = 2) THEN (stat.a).stavalues2 WHEN ((stat.a).stakind3 = 2) THEN (stat.a).stavalues3 WHEN ((stat.a).stakind4 = 2) THEN (stat.a).stavalues4 WHEN ((stat.a).stakind5 = 2) THEN (stat.a).stavalues5 ELSE NULL::anyarray END AS histogram_bounds, CASE WHEN ((stat.a).stakind1 = 3) THEN (stat.a).stanumbers1[1] WHEN ((stat.a).stakind2 = 3) THEN (stat.a).stanumbers2[1] WHEN ((stat.a).stakind3 = 3) THEN (stat.a).stanumbers3[1] WHEN ((stat.a).stakind4 = 3) THEN (stat.a).stanumbers4[1] WHEN ((stat.a).stakind5 = 3) THEN (stat.a).stanumbers5[1] ELSE NULL::real END AS correlation, CASE WHEN ((stat.a).stakind1 = 4) THEN (stat.a).stavalues1 WHEN ((stat.a).stakind2 = 4) THEN (stat.a).stavalues2 WHEN ((stat.a).stakind3 = 4) THEN (stat.a).stavalues3 WHEN ((stat.a).stakind4 = 4) THEN (stat.a).stavalues4 WHEN ((stat.a).stakind5 = 4) THEN (stat.a).stavalues5 ELSE NULL::anyarray END AS most_common_elems, CASE WHEN ((stat.a).stakind1 = 4) THEN (stat.a).stanumbers1 WHEN ((stat.a).stakind2 = 4) THEN (stat.a).stanumbers2 WHEN ((stat.a).stakind3 = 4) THEN (stat.a).stanumbers3 WHEN ((stat.a).stakind4 = 4) THEN (stat.a).stanumbers4 WHEN ((stat.a).stakind5 = 4) THEN (stat.a).stanumbers5 ELSE NULL::real[] END AS most_common_elem_freqs, CASE WHEN ((stat.a).stakind1 = 5) THEN (stat.a).stanumbers1 WHEN ((stat.a).stakind2 = 5) THEN (stat.a).stanumbers2 WHEN ((stat.a).stakind3 = 5) THEN (stat.a).stanumbers3 WHEN ((stat.a).stakind4 = 5) THEN (stat.a).stanumbers4 WHEN ((stat.a).stakind5 = 5) THEN (stat.a).stanumbers5 ELSE NULL::real[] END AS elem_count_histogram FROM (((((pg_statistic_ext s JOIN pg_class c ON ((c.oid = s.stxrelid))) LEFT JOIN pg_statistic_ext_data sd ON ((s.oid = sd.stxoid))) LEFT JOIN pg_namespace cn ON ((cn.oid = c.relnamespace))) LEFT JOIN pg_namespace sn ON ((sn.oid = s.stxnamespace))) JOIN LATERAL ( SELECT unnest(pg_get_statisticsobjdef_expressions(s.oid)) AS expr, unnest(sd.stxdexpr) AS a) stat ON ((stat.expr IS NOT NULL))); pg_tables| SELECT n.nspname AS schemaname, c.relname AS tablename, pg_get_userbyid(c.relowner) AS tableowner, t.spcname AS tablespace, c.relhasindex AS hasindexes, c.relhasrules AS hasrules, c.relhastriggers AS hastriggers, c.relrowsecurity AS rowsecurity FROM ((pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) LEFT JOIN pg_tablespace t ON ((t.oid = c.reltablespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 'p'::"char"])); pg_timezone_abbrevs| SELECT abbrev, utc_offset, is_dst FROM pg_timezone_abbrevs() pg_timezone_abbrevs(abbrev, utc_offset, is_dst); pg_timezone_names| SELECT name, abbrev, utc_offset, is_dst FROM pg_timezone_names() pg_timezone_names(name, abbrev, utc_offset, is_dst); pg_user| SELECT usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, '********'::text AS passwd, valuntil, useconfig FROM pg_shadow; pg_user_mappings| SELECT u.oid AS umid, s.oid AS srvid, s.srvname, u.umuser, CASE WHEN (u.umuser = (0)::oid) THEN 'public'::name ELSE a.rolname END AS usename, CASE WHEN (((u.umuser <> (0)::oid) AND (a.rolname = CURRENT_USER) AND (pg_has_role(s.srvowner, 'USAGE'::text) OR has_server_privilege(s.oid, 'USAGE'::text))) OR ((u.umuser = (0)::oid) AND pg_has_role(s.srvowner, 'USAGE'::text)) OR ( SELECT pg_authid.rolsuper FROM pg_authid WHERE (pg_authid.rolname = CURRENT_USER))) THEN u.umoptions ELSE NULL::text[] END AS umoptions FROM ((pg_user_mapping u JOIN pg_foreign_server s ON ((u.umserver = s.oid))) LEFT JOIN pg_authid a ON ((a.oid = u.umuser))); pg_views| SELECT n.nspname AS schemaname, c.relname AS viewname, pg_get_userbyid(c.relowner) AS viewowner, pg_get_viewdef(c.oid) AS definition FROM (pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'v'::"char"); pg_wait_events| SELECT type, name, description FROM pg_get_wait_events() pg_get_wait_events(type, name, description); SELECT tablename, rulename, definition FROM pg_rules WHERE schemaname = 'pg_catalog' ORDER BY tablename, rulename; pg_settings|pg_settings_n|CREATE RULE pg_settings_n AS ON UPDATE TO pg_catalog.pg_settings DO INSTEAD NOTHING; pg_settings|pg_settings_u|CREATE RULE pg_settings_u AS ON UPDATE TO pg_catalog.pg_settings WHERE (new.name = old.name) DO SELECT set_config(old.name, new.setting, false) AS set_config; -- restore normal output mode \a\t -- -- CREATE OR REPLACE RULE -- CREATE TABLE ruletest_tbl (a int, b int); CREATE TABLE ruletest_tbl2 (a int, b int); CREATE OR REPLACE RULE myrule AS ON INSERT TO ruletest_tbl DO INSTEAD INSERT INTO ruletest_tbl2 VALUES (10, 10); INSERT INTO ruletest_tbl VALUES (99, 99); CREATE OR REPLACE RULE myrule AS ON INSERT TO ruletest_tbl DO INSTEAD INSERT INTO ruletest_tbl2 VALUES (1000, 1000); INSERT INTO ruletest_tbl VALUES (99, 99); SELECT * FROM ruletest_tbl2; a | b ------+------ 10 | 10 1000 | 1000 (2 rows) -- Check that rewrite rules splitting one INSERT into multiple -- conditional statements does not disable FK checking. create table rule_and_refint_t1 ( id1a integer, id1b integer, primary key (id1a, id1b) ); create table rule_and_refint_t2 ( id2a integer, id2c integer, primary key (id2a, id2c) ); create table rule_and_refint_t3 ( id3a integer, id3b integer, id3c integer, data text, primary key (id3a, id3b, id3c), foreign key (id3a, id3b) references rule_and_refint_t1 (id1a, id1b), foreign key (id3a, id3c) references rule_and_refint_t2 (id2a, id2c) ); insert into rule_and_refint_t1 values (1, 11); insert into rule_and_refint_t1 values (1, 12); insert into rule_and_refint_t1 values (2, 21); insert into rule_and_refint_t1 values (2, 22); insert into rule_and_refint_t2 values (1, 11); insert into rule_and_refint_t2 values (1, 12); insert into rule_and_refint_t2 values (2, 21); insert into rule_and_refint_t2 values (2, 22); insert into rule_and_refint_t3 values (1, 11, 11, 'row1'); insert into rule_and_refint_t3 values (1, 11, 12, 'row2'); insert into rule_and_refint_t3 values (1, 12, 11, 'row3'); insert into rule_and_refint_t3 values (1, 12, 12, 'row4'); insert into rule_and_refint_t3 values (1, 11, 13, 'row5'); ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3c_fkey" DETAIL: Key (id3a, id3c)=(1, 13) is not present in table "rule_and_refint_t2". insert into rule_and_refint_t3 values (1, 13, 11, 'row6'); ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3b_fkey" DETAIL: Key (id3a, id3b)=(1, 13) is not present in table "rule_and_refint_t1". -- Ordinary table insert into rule_and_refint_t3 values (1, 13, 11, 'row6') on conflict do nothing; ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3b_fkey" DETAIL: Key (id3a, id3b)=(1, 13) is not present in table "rule_and_refint_t1". -- rule not fired, so fk violation insert into rule_and_refint_t3 values (1, 13, 11, 'row6') on conflict (id3a, id3b, id3c) do update set id3b = excluded.id3b; ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3b_fkey" DETAIL: Key (id3a, id3b)=(1, 13) is not present in table "rule_and_refint_t1". -- rule fired, so unsupported insert into shoelace values ('sl9', 0, 'pink', 35.0, 'inch', 0.0) on conflict (sl_name) do update set sl_avail = excluded.sl_avail; ERROR: INSERT with ON CONFLICT clause cannot be used with table that has INSERT or UPDATE rules create rule rule_and_refint_t3_ins as on insert to rule_and_refint_t3 where (exists (select 1 from rule_and_refint_t3 where (((rule_and_refint_t3.id3a = new.id3a) and (rule_and_refint_t3.id3b = new.id3b)) and (rule_and_refint_t3.id3c = new.id3c)))) do instead update rule_and_refint_t3 set data = new.data where (((rule_and_refint_t3.id3a = new.id3a) and (rule_and_refint_t3.id3b = new.id3b)) and (rule_and_refint_t3.id3c = new.id3c)); insert into rule_and_refint_t3 values (1, 11, 13, 'row7'); ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3c_fkey" DETAIL: Key (id3a, id3c)=(1, 13) is not present in table "rule_and_refint_t2". insert into rule_and_refint_t3 values (1, 13, 11, 'row8'); ERROR: insert or update on table "rule_and_refint_t3" violates foreign key constraint "rule_and_refint_t3_id3a_id3b_fkey" DETAIL: Key (id3a, id3b)=(1, 13) is not present in table "rule_and_refint_t1". -- -- disallow dropping a view's rule (bug #5072) -- create view rules_fooview as select 'rules_foo'::text; drop rule "_RETURN" on rules_fooview; ERROR: cannot drop rule _RETURN on view rules_fooview because view rules_fooview requires it HINT: You can drop view rules_fooview instead. drop view rules_fooview; -- -- We used to allow converting a table to a view by creating a "_RETURN" -- rule for it, but no more. -- create table rules_fooview (x int, y text); create rule "_RETURN" as on select to rules_fooview do instead select 1 as x, 'aaa'::text as y; ERROR: relation "rules_fooview" cannot have ON SELECT rules DETAIL: This operation is not supported for tables. drop table rules_fooview; -- likewise, converting a partitioned table or partition to view is not allowed create table rules_fooview (x int, y text) partition by list (x); create rule "_RETURN" as on select to rules_fooview do instead select 1 as x, 'aaa'::text as y; ERROR: relation "rules_fooview" cannot have ON SELECT rules DETAIL: This operation is not supported for partitioned tables. create table rules_fooview_part partition of rules_fooview for values in (1); create rule "_RETURN" as on select to rules_fooview_part do instead select 1 as x, 'aaa'::text as y; ERROR: relation "rules_fooview_part" cannot have ON SELECT rules DETAIL: This operation is not supported for tables. drop table rules_fooview; -- -- check for planner problems with complex inherited UPDATES -- create table id (id serial primary key, name text); -- currently, must respecify PKEY for each inherited subtable create table test_1 (id integer primary key) inherits (id); NOTICE: merging column "id" with inherited definition create table test_2 (id integer primary key) inherits (id); NOTICE: merging column "id" with inherited definition create table test_3 (id integer primary key) inherits (id); NOTICE: merging column "id" with inherited definition insert into test_1 (name) values ('Test 1'); insert into test_1 (name) values ('Test 2'); insert into test_2 (name) values ('Test 3'); insert into test_2 (name) values ('Test 4'); insert into test_3 (name) values ('Test 5'); insert into test_3 (name) values ('Test 6'); create view id_ordered as select * from id order by id; create rule update_id_ordered as on update to id_ordered do instead update id set name = new.name where id = old.id; select * from id_ordered; id | name ----+-------- 1 | Test 1 2 | Test 2 3 | Test 3 4 | Test 4 5 | Test 5 6 | Test 6 (6 rows) update id_ordered set name = 'update 2' where id = 2; update id_ordered set name = 'update 4' where id = 4; update id_ordered set name = 'update 5' where id = 5; select * from id_ordered; id | name ----+---------- 1 | Test 1 2 | update 2 3 | Test 3 4 | update 4 5 | update 5 6 | Test 6 (6 rows) drop table id cascade; NOTICE: drop cascades to 4 other objects DETAIL: drop cascades to table test_1 drop cascades to table test_2 drop cascades to table test_3 drop cascades to view id_ordered -- -- check corner case where an entirely-dummy subplan is created by -- constraint exclusion -- create temp table t1 (a integer primary key); create temp table t1_1 (check (a >= 0 and a < 10)) inherits (t1); create temp table t1_2 (check (a >= 10 and a < 20)) inherits (t1); create rule t1_ins_1 as on insert to t1 where new.a >= 0 and new.a < 10 do instead insert into t1_1 values (new.a); create rule t1_ins_2 as on insert to t1 where new.a >= 10 and new.a < 20 do instead insert into t1_2 values (new.a); create rule t1_upd_1 as on update to t1 where old.a >= 0 and old.a < 10 do instead update t1_1 set a = new.a where a = old.a; create rule t1_upd_2 as on update to t1 where old.a >= 10 and old.a < 20 do instead update t1_2 set a = new.a where a = old.a; set constraint_exclusion = on; insert into t1 select * from generate_series(5,19,1) g; update t1 set a = 4 where a = 5; select * from only t1; a --- (0 rows) select * from only t1_1; a --- 6 7 8 9 4 (5 rows) select * from only t1_2; a ---- 10 11 12 13 14 15 16 17 18 19 (10 rows) reset constraint_exclusion; -- test FOR UPDATE in rules create table rules_base(f1 int, f2 int); insert into rules_base values(1,2), (11,12); create rule r1 as on update to rules_base do instead select * from rules_base where f1 = 1 for update; update rules_base set f2 = f2 + 1; f1 | f2 ----+---- 1 | 2 (1 row) create or replace rule r1 as on update to rules_base do instead select * from rules_base where f1 = 11 for update of rules_base; update rules_base set f2 = f2 + 1; f1 | f2 ----+---- 11 | 12 (1 row) create or replace rule r1 as on update to rules_base do instead select * from rules_base where f1 = 11 for update of old; -- error ERROR: relation "old" in FOR UPDATE clause not found in FROM clause LINE 2: select * from rules_base where f1 = 11 for update of old; ^ drop table rules_base; -- test various flavors of pg_get_viewdef() select pg_get_viewdef('shoe'::regclass) as unpretty; unpretty ------------------------------------------------ SELECT sh.shoename, + sh.sh_avail, + sh.slcolor, + sh.slminlen, + (sh.slminlen * un.un_fact) AS slminlen_cm,+ sh.slmaxlen, + (sh.slmaxlen * un.un_fact) AS slmaxlen_cm,+ sh.slunit + FROM shoe_data sh, + unit un + WHERE (sh.slunit = un.un_name); (1 row) select pg_get_viewdef('shoe'::regclass,true) as pretty; pretty ---------------------------------------------- SELECT sh.shoename, + sh.sh_avail, + sh.slcolor, + sh.slminlen, + sh.slminlen * un.un_fact AS slminlen_cm,+ sh.slmaxlen, + sh.slmaxlen * un.un_fact AS slmaxlen_cm,+ sh.slunit + FROM shoe_data sh, + unit un + WHERE sh.slunit = un.un_name; (1 row) select pg_get_viewdef('shoe'::regclass,0) as prettier; prettier ---------------------------------------------- SELECT sh.shoename, + sh.sh_avail, + sh.slcolor, + sh.slminlen, + sh.slminlen * un.un_fact AS slminlen_cm,+ sh.slmaxlen, + sh.slmaxlen * un.un_fact AS slmaxlen_cm,+ sh.slunit + FROM shoe_data sh, + unit un + WHERE sh.slunit = un.un_name; (1 row) -- -- check multi-row VALUES in rules -- create table rules_src(f1 int, f2 int default 0); create table rules_log(f1 int, f2 int, tag text, id serial); insert into rules_src values(1,2), (11,12); create rule r1 as on update to rules_src do also insert into rules_log values(old.*, 'old', default), (new.*, 'new', default); update rules_src set f2 = f2 + 1; update rules_src set f2 = f2 * 10; select * from rules_src; f1 | f2 ----+----- 1 | 30 11 | 130 (2 rows) select * from rules_log; f1 | f2 | tag | id ----+-----+-----+---- 1 | 2 | old | 1 1 | 3 | new | 2 11 | 12 | old | 3 11 | 13 | new | 4 1 | 3 | old | 5 1 | 30 | new | 6 11 | 13 | old | 7 11 | 130 | new | 8 (8 rows) create rule r2 as on update to rules_src do also values(old.*, 'old'), (new.*, 'new'); update rules_src set f2 = f2 / 10; column1 | column2 | column3 ---------+---------+--------- 1 | 30 | old 1 | 3 | new 11 | 130 | old 11 | 13 | new (4 rows) create rule r3 as on insert to rules_src do also insert into rules_log values(null, null, '-', default), (new.*, 'new', default); insert into rules_src values(22,23), (33,default); select * from rules_src; f1 | f2 ----+---- 1 | 3 11 | 13 22 | 23 33 | 0 (4 rows) select * from rules_log; f1 | f2 | tag | id ----+-----+-----+---- 1 | 2 | old | 1 1 | 3 | new | 2 11 | 12 | old | 3 11 | 13 | new | 4 1 | 3 | old | 5 1 | 30 | new | 6 11 | 13 | old | 7 11 | 130 | new | 8 1 | 30 | old | 9 1 | 3 | new | 10 11 | 130 | old | 11 11 | 13 | new | 12 | | - | 13 22 | 23 | new | 14 | | - | 15 33 | 0 | new | 16 (16 rows) create rule r4 as on delete to rules_src do notify rules_src_deletion; -- -- Ensure an aliased target relation for insert is correctly deparsed. -- create rule r5 as on insert to rules_src do instead insert into rules_log AS trgt SELECT NEW.* RETURNING trgt.f1, trgt.f2; create rule r6 as on update to rules_src do instead UPDATE rules_log AS trgt SET tag = 'updated' WHERE trgt.f1 = new.f1; -- -- Check deparse disambiguation of INSERT/UPDATE/DELETE targets. -- create rule r7 as on delete to rules_src do instead with wins as (insert into int4_tbl as trgt values (0) returning *), wupd as (update int4_tbl trgt set f1 = f1+1 returning *), wdel as (delete from int4_tbl trgt where f1 = 0 returning *) insert into rules_log AS trgt select old.* from wins, wupd, wdel returning trgt.f1, trgt.f2; -- check display of all rules added above \d+ rules_src Table "public.rules_src" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------+---------+-----------+----------+---------+---------+--------------+------------- f1 | integer | | | | plain | | f2 | integer | | | 0 | plain | | Rules: r1 AS ON UPDATE TO rules_src DO INSERT INTO rules_log (f1, f2, tag, id) VALUES (old.f1,old.f2,'old'::text,DEFAULT), (new.f1,new.f2,'new'::text,DEFAULT) r2 AS ON UPDATE TO rules_src DO VALUES (old.f1,old.f2,'old'::text), (new.f1,new.f2,'new'::text) r3 AS ON INSERT TO rules_src DO INSERT INTO rules_log (f1, f2, tag, id) VALUES (NULL::integer,NULL::integer,'-'::text,DEFAULT), (new.f1,new.f2,'new'::text,DEFAULT) r4 AS ON DELETE TO rules_src DO NOTIFY rules_src_deletion r5 AS ON INSERT TO rules_src DO INSTEAD INSERT INTO rules_log AS trgt (f1, f2) SELECT new.f1, new.f2 RETURNING trgt.f1, trgt.f2 r6 AS ON UPDATE TO rules_src DO INSTEAD UPDATE rules_log trgt SET tag = 'updated'::text WHERE trgt.f1 = new.f1 r7 AS ON DELETE TO rules_src DO INSTEAD WITH wins AS ( INSERT INTO int4_tbl AS trgt_1 (f1) VALUES (0) RETURNING trgt_1.f1 ), wupd AS ( UPDATE int4_tbl trgt_1 SET f1 = trgt_1.f1 + 1 RETURNING trgt_1.f1 ), wdel AS ( DELETE FROM int4_tbl trgt_1 WHERE trgt_1.f1 = 0 RETURNING trgt_1.f1 ) INSERT INTO rules_log AS trgt (f1, f2) SELECT old.f1, old.f2 FROM wins, wupd, wdel RETURNING trgt.f1, trgt.f2 -- -- Also check multiassignment deparsing. -- create table rule_t1(f1 int, f2 int); create table rule_dest(f1 int, f2 int[], tag text); create rule rr as on update to rule_t1 do instead UPDATE rule_dest trgt SET (f2[1], f1, tag) = (SELECT new.f2, new.f1, 'updated'::varchar) WHERE trgt.f1 = new.f1 RETURNING new.*; \d+ rule_t1 Table "public.rule_t1" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------+---------+-----------+----------+---------+---------+--------------+------------- f1 | integer | | | | plain | | f2 | integer | | | | plain | | Rules: rr AS ON UPDATE TO rule_t1 DO INSTEAD UPDATE rule_dest trgt SET (f2[1], f1, tag) = ( SELECT new.f2, new.f1, 'updated'::character varying AS "varchar") WHERE trgt.f1 = new.f1 RETURNING new.f1, new.f2 drop table rule_t1, rule_dest; -- -- Test implicit LATERAL references to old/new in rules -- CREATE TABLE rule_t1(a int, b text DEFAULT 'xxx', c int); CREATE VIEW rule_v1 AS SELECT * FROM rule_t1; CREATE RULE v1_ins AS ON INSERT TO rule_v1 DO ALSO INSERT INTO rule_t1 SELECT * FROM (SELECT a + 10 FROM rule_t1 WHERE a = NEW.a) tt; CREATE RULE v1_upd AS ON UPDATE TO rule_v1 DO ALSO UPDATE rule_t1 t SET c = tt.a * 10 FROM (SELECT a FROM rule_t1 WHERE a = OLD.a) tt WHERE t.a = tt.a; INSERT INTO rule_v1 VALUES (1, 'a'), (2, 'b'); UPDATE rule_v1 SET b = upper(b); SELECT * FROM rule_t1; a | b | c ----+-----+----- 1 | A | 10 2 | B | 20 11 | XXX | 110 12 | XXX | 120 (4 rows) DROP TABLE rule_t1 CASCADE; NOTICE: drop cascades to view rule_v1 -- -- check alter rename rule -- CREATE TABLE rule_t1 (a INT); CREATE VIEW rule_v1 AS SELECT * FROM rule_t1; CREATE RULE InsertRule AS ON INSERT TO rule_v1 DO INSTEAD INSERT INTO rule_t1 VALUES(new.a); ALTER RULE InsertRule ON rule_v1 RENAME to NewInsertRule; INSERT INTO rule_v1 VALUES(1); SELECT * FROM rule_v1; a --- 1 (1 row) \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- a | integer | | | | plain | View definition: SELECT a FROM rule_t1; Rules: newinsertrule AS ON INSERT TO rule_v1 DO INSTEAD INSERT INTO rule_t1 (a) VALUES (new.a) -- -- error conditions for alter rename rule -- ALTER RULE InsertRule ON rule_v1 RENAME TO NewInsertRule; -- doesn't exist ERROR: rule "insertrule" for relation "rule_v1" does not exist ALTER RULE NewInsertRule ON rule_v1 RENAME TO "_RETURN"; -- already exists ERROR: rule "_RETURN" for relation "rule_v1" already exists ALTER RULE "_RETURN" ON rule_v1 RENAME TO abc; -- ON SELECT rule cannot be renamed ERROR: renaming an ON SELECT rule is not allowed DROP VIEW rule_v1; DROP TABLE rule_t1; -- -- check display of VALUES in view definitions -- create view rule_v1 as values(1,2); \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description ---------+---------+-----------+----------+---------+---------+------------- column1 | integer | | | | plain | column2 | integer | | | | plain | View definition: VALUES (1,2); alter table rule_v1 rename column column2 to q2; \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description ---------+---------+-----------+----------+---------+---------+------------- column1 | integer | | | | plain | q2 | integer | | | | plain | View definition: SELECT column1, column2 AS q2 FROM (VALUES (1,2)) "*VALUES*"; drop view rule_v1; create view rule_v1(x) as values(1,2); \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description ---------+---------+-----------+----------+---------+---------+------------- x | integer | | | | plain | column2 | integer | | | | plain | View definition: SELECT column1 AS x, column2 FROM (VALUES (1,2)) "*VALUES*"; drop view rule_v1; create view rule_v1(x) as select * from (values(1,2)) v; \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description ---------+---------+-----------+----------+---------+---------+------------- x | integer | | | | plain | column2 | integer | | | | plain | View definition: SELECT column1 AS x, column2 FROM ( VALUES (1,2)) v; drop view rule_v1; create view rule_v1(x) as select * from (values(1,2)) v(q,w); \d+ rule_v1 View "public.rule_v1" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- x | integer | | | | plain | w | integer | | | | plain | View definition: SELECT q AS x, w FROM ( VALUES (1,2)) v(q, w); drop view rule_v1; -- -- Check DO INSTEAD rules with ON CONFLICT -- CREATE TABLE hats ( hat_name char(10) primary key, hat_color char(10) -- hat color ); CREATE TABLE hat_data ( hat_name char(10), hat_color char(10) -- hat color ); create unique index hat_data_unique_idx on hat_data (hat_name COLLATE "C" bpchar_pattern_ops); -- DO NOTHING with ON CONFLICT CREATE RULE hat_nosert AS ON INSERT TO hats DO INSTEAD INSERT INTO hat_data VALUES ( NEW.hat_name, NEW.hat_color) ON CONFLICT (hat_name COLLATE "C" bpchar_pattern_ops) WHERE hat_color = 'green' DO NOTHING RETURNING *; SELECT definition FROM pg_rules WHERE tablename = 'hats' ORDER BY rulename; definition --------------------------------------------------------------------------------------------- CREATE RULE hat_nosert AS + ON INSERT TO public.hats DO INSTEAD INSERT INTO hat_data (hat_name, hat_color) + VALUES (new.hat_name, new.hat_color) ON CONFLICT(hat_name COLLATE "C" bpchar_pattern_ops)+ WHERE (hat_color = 'green'::bpchar) DO NOTHING + RETURNING hat_data.hat_name, + hat_data.hat_color; (1 row) -- Works (projects row) INSERT INTO hats VALUES ('h7', 'black') RETURNING *; hat_name | hat_color ------------+------------ h7 | black (1 row) -- Works (does nothing) INSERT INTO hats VALUES ('h7', 'black') RETURNING *; hat_name | hat_color ----------+----------- (0 rows) SELECT tablename, rulename, definition FROM pg_rules WHERE tablename = 'hats'; tablename | rulename | definition -----------+------------+--------------------------------------------------------------------------------------------- hats | hat_nosert | CREATE RULE hat_nosert AS + | | ON INSERT TO public.hats DO INSTEAD INSERT INTO hat_data (hat_name, hat_color) + | | VALUES (new.hat_name, new.hat_color) ON CONFLICT(hat_name COLLATE "C" bpchar_pattern_ops)+ | | WHERE (hat_color = 'green'::bpchar) DO NOTHING + | | RETURNING hat_data.hat_name, + | | hat_data.hat_color; (1 row) DROP RULE hat_nosert ON hats; -- DO NOTHING without ON CONFLICT CREATE RULE hat_nosert_all AS ON INSERT TO hats DO INSTEAD INSERT INTO hat_data VALUES ( NEW.hat_name, NEW.hat_color) ON CONFLICT DO NOTHING RETURNING *; SELECT definition FROM pg_rules WHERE tablename = 'hats' ORDER BY rulename; definition ------------------------------------------------------------------------------------- CREATE RULE hat_nosert_all AS + ON INSERT TO public.hats DO INSTEAD INSERT INTO hat_data (hat_name, hat_color)+ VALUES (new.hat_name, new.hat_color) ON CONFLICT DO NOTHING + RETURNING hat_data.hat_name, + hat_data.hat_color; (1 row) DROP RULE hat_nosert_all ON hats; -- Works (does nothing) INSERT INTO hats VALUES ('h7', 'black') RETURNING *; hat_name | hat_color ------------+------------ h7 | black (1 row) -- DO UPDATE with a WHERE clause CREATE RULE hat_upsert AS ON INSERT TO hats DO INSTEAD INSERT INTO hat_data VALUES ( NEW.hat_name, NEW.hat_color) ON CONFLICT (hat_name) DO UPDATE SET hat_name = hat_data.hat_name, hat_color = excluded.hat_color WHERE excluded.hat_color <> 'forbidden' AND hat_data.* != excluded.* RETURNING *; SELECT definition FROM pg_rules WHERE tablename = 'hats' ORDER BY rulename; definition ----------------------------------------------------------------------------------------------------------------------------------------- CREATE RULE hat_upsert AS + ON INSERT TO public.hats DO INSTEAD INSERT INTO hat_data (hat_name, hat_color) + VALUES (new.hat_name, new.hat_color) ON CONFLICT(hat_name) DO UPDATE SET hat_name = hat_data.hat_name, hat_color = excluded.hat_color+ WHERE ((excluded.hat_color <> 'forbidden'::bpchar) AND (hat_data.* <> excluded.*)) + RETURNING hat_data.hat_name, + hat_data.hat_color; (1 row) -- Works (does upsert) INSERT INTO hats VALUES ('h8', 'black') RETURNING *; hat_name | hat_color ------------+------------ h8 | black (1 row) SELECT * FROM hat_data WHERE hat_name = 'h8'; hat_name | hat_color ------------+------------ h8 | black (1 row) INSERT INTO hats VALUES ('h8', 'white') RETURNING *; hat_name | hat_color ------------+------------ h8 | white (1 row) SELECT * FROM hat_data WHERE hat_name = 'h8'; hat_name | hat_color ------------+------------ h8 | white (1 row) INSERT INTO hats VALUES ('h8', 'forbidden') RETURNING *; hat_name | hat_color ----------+----------- (0 rows) SELECT * FROM hat_data WHERE hat_name = 'h8'; hat_name | hat_color ------------+------------ h8 | white (1 row) SELECT tablename, rulename, definition FROM pg_rules WHERE tablename = 'hats'; tablename | rulename | definition -----------+------------+----------------------------------------------------------------------------------------------------------------------------------------- hats | hat_upsert | CREATE RULE hat_upsert AS + | | ON INSERT TO public.hats DO INSTEAD INSERT INTO hat_data (hat_name, hat_color) + | | VALUES (new.hat_name, new.hat_color) ON CONFLICT(hat_name) DO UPDATE SET hat_name = hat_data.hat_name, hat_color = excluded.hat_color+ | | WHERE ((excluded.hat_color <> 'forbidden'::bpchar) AND (hat_data.* <> excluded.*)) + | | RETURNING hat_data.hat_name, + | | hat_data.hat_color; (1 row) -- ensure explain works for on insert conflict rules explain (costs off) INSERT INTO hats VALUES ('h8', 'forbidden') RETURNING *; QUERY PLAN ------------------------------------------------------------------------------------------------- Insert on hat_data Conflict Resolution: UPDATE Conflict Arbiter Indexes: hat_data_unique_idx Conflict Filter: ((excluded.hat_color <> 'forbidden'::bpchar) AND (hat_data.* <> excluded.*)) -> Result (5 rows) -- ensure upserting into a rule, with a CTE (different offsets!) works WITH data(hat_name, hat_color) AS MATERIALIZED ( VALUES ('h8', 'green'), ('h9', 'blue'), ('h7', 'forbidden') ) INSERT INTO hats SELECT * FROM data RETURNING *; hat_name | hat_color ------------+------------ h8 | green h9 | blue (2 rows) EXPLAIN (costs off) WITH data(hat_name, hat_color) AS MATERIALIZED ( VALUES ('h8', 'green'), ('h9', 'blue'), ('h7', 'forbidden') ) INSERT INTO hats SELECT * FROM data RETURNING *; QUERY PLAN ------------------------------------------------------------------------------------------------- Insert on hat_data Conflict Resolution: UPDATE Conflict Arbiter Indexes: hat_data_unique_idx Conflict Filter: ((excluded.hat_color <> 'forbidden'::bpchar) AND (hat_data.* <> excluded.*)) CTE data -> Values Scan on "*VALUES*" -> CTE Scan on data (7 rows) SELECT * FROM hat_data WHERE hat_name IN ('h8', 'h9', 'h7') ORDER BY hat_name; hat_name | hat_color ------------+------------ h7 | black h8 | green h9 | blue (3 rows) DROP RULE hat_upsert ON hats; drop table hats; drop table hat_data; -- test for pg_get_functiondef properly regurgitating SET parameters -- Note that the function is kept around to stress pg_dump. CREATE FUNCTION func_with_set_params() RETURNS integer AS 'select 1;' LANGUAGE SQL SET search_path TO PG_CATALOG SET extra_float_digits TO 2 SET work_mem TO '4MB' SET datestyle to iso, mdy SET local_preload_libraries TO "Mixed/Case", 'c:/''a"/path', '', '0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789' IMMUTABLE STRICT; SELECT pg_get_functiondef('func_with_set_params()'::regprocedure); pg_get_functiondef -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- CREATE OR REPLACE FUNCTION public.func_with_set_params() + RETURNS integer + LANGUAGE sql + IMMUTABLE STRICT + SET search_path TO 'pg_catalog' + SET extra_float_digits TO '2' + SET work_mem TO '4MB' + SET "DateStyle" TO 'iso, mdy' + SET local_preload_libraries TO 'Mixed/Case', 'c:/''a"/path', '', '0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789'+ AS $function$select 1;$function$ + (1 row) -- tests for pg_get_*def with invalid objects SELECT pg_get_constraintdef(0); pg_get_constraintdef ---------------------- (1 row) SELECT pg_get_functiondef(0); pg_get_functiondef -------------------- (1 row) SELECT pg_get_indexdef(0); pg_get_indexdef ----------------- (1 row) SELECT pg_get_ruledef(0); pg_get_ruledef ---------------- (1 row) SELECT pg_get_statisticsobjdef(0); pg_get_statisticsobjdef ------------------------- (1 row) SELECT pg_get_triggerdef(0); pg_get_triggerdef ------------------- (1 row) SELECT pg_get_viewdef(0); pg_get_viewdef ---------------- (1 row) SELECT pg_get_function_arguments(0); pg_get_function_arguments --------------------------- (1 row) SELECT pg_get_function_identity_arguments(0); pg_get_function_identity_arguments ------------------------------------ (1 row) SELECT pg_get_function_result(0); pg_get_function_result ------------------------ (1 row) SELECT pg_get_function_arg_default(0, 0); pg_get_function_arg_default ----------------------------- (1 row) SELECT pg_get_function_arg_default('pg_class'::regclass, 0); pg_get_function_arg_default ----------------------------- (1 row) SELECT pg_get_partkeydef(0); pg_get_partkeydef ------------------- (1 row) -- test rename for a rule defined on a partitioned table CREATE TABLE rules_parted_table (a int) PARTITION BY LIST (a); CREATE TABLE rules_parted_table_1 PARTITION OF rules_parted_table FOR VALUES IN (1); CREATE RULE rules_parted_table_insert AS ON INSERT to rules_parted_table DO INSTEAD INSERT INTO rules_parted_table_1 VALUES (NEW.*); ALTER RULE rules_parted_table_insert ON rules_parted_table RENAME TO rules_parted_table_insert_redirect; DROP TABLE rules_parted_table; -- -- test MERGE -- CREATE TABLE rule_merge1 (a int, b text); CREATE TABLE rule_merge2 (a int, b text); CREATE RULE rule1 AS ON INSERT TO rule_merge1 DO INSTEAD INSERT INTO rule_merge2 VALUES (NEW.*); CREATE RULE rule2 AS ON UPDATE TO rule_merge1 DO INSTEAD UPDATE rule_merge2 SET a = NEW.a, b = NEW.b WHERE a = OLD.a; CREATE RULE rule3 AS ON DELETE TO rule_merge1 DO INSTEAD DELETE FROM rule_merge2 WHERE a = OLD.a; -- MERGE not supported for table with rules MERGE INTO rule_merge1 t USING (SELECT 1 AS a) s ON t.a = s.a WHEN MATCHED AND t.a < 2 THEN UPDATE SET b = b || ' updated by merge' WHEN MATCHED AND t.a > 2 THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.a, ''); ERROR: cannot execute MERGE on relation "rule_merge1" DETAIL: MERGE is not supported for relations with rules. -- should be ok with the other table though MERGE INTO rule_merge2 t USING (SELECT 1 AS a) s ON t.a = s.a WHEN MATCHED AND t.a < 2 THEN UPDATE SET b = b || ' updated by merge' WHEN MATCHED AND t.a > 2 THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.a, ''); -- also ok if the rules are disabled ALTER TABLE rule_merge1 DISABLE RULE rule1; ALTER TABLE rule_merge1 DISABLE RULE rule2; ALTER TABLE rule_merge1 DISABLE RULE rule3; MERGE INTO rule_merge1 t USING (SELECT 1 AS a) s ON t.a = s.a WHEN MATCHED AND t.a < 2 THEN UPDATE SET b = b || ' updated by merge' WHEN MATCHED AND t.a > 2 THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.a, ''); -- test deparsing CREATE TABLE sf_target(id int, data text, filling int[]); CREATE FUNCTION merge_sf_test() RETURNS TABLE(action text, a int, b text, id int, data text, filling int[]) LANGUAGE sql BEGIN ATOMIC MERGE INTO sf_target t USING rule_merge1 s ON (s.a = t.id) WHEN MATCHED AND (s.a + t.id) = 42 THEN UPDATE SET data = repeat(t.data, s.a) || s.b, id = length(s.b) WHEN NOT MATCHED AND (s.b IS NOT NULL) THEN INSERT (data, id) VALUES (s.b, s.a) WHEN MATCHED AND length(s.b || t.data) > 10 THEN UPDATE SET data = s.b WHEN MATCHED AND s.a > 200 THEN UPDATE SET filling[s.a] = t.id WHEN MATCHED AND s.a > 100 THEN DELETE WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED AND s.a > 200 THEN INSERT DEFAULT VALUES WHEN NOT MATCHED AND s.a > 100 THEN INSERT (id, data) OVERRIDING USER VALUE VALUES (s.a, DEFAULT) WHEN NOT MATCHED AND s.a > 0 THEN INSERT VALUES (s.a, s.b, DEFAULT) WHEN NOT MATCHED THEN INSERT (filling[1], id) VALUES (s.a, s.a) RETURNING merge_action() AS action, *; END; \sf merge_sf_test CREATE OR REPLACE FUNCTION public.merge_sf_test() RETURNS TABLE(action text, a integer, b text, id integer, data text, filling integer[]) LANGUAGE sql BEGIN ATOMIC MERGE INTO sf_target t USING rule_merge1 s ON (s.a = t.id) WHEN MATCHED AND ((s.a + t.id) = 42) THEN UPDATE SET data = (repeat(t.data, s.a) || s.b), id = length(s.b) WHEN NOT MATCHED AND (s.b IS NOT NULL) THEN INSERT (data, id) VALUES (s.b, s.a) WHEN MATCHED AND (length((s.b || t.data)) > 10) THEN UPDATE SET data = s.b WHEN MATCHED AND (s.a > 200) THEN UPDATE SET filling[s.a] = t.id WHEN MATCHED AND (s.a > 100) THEN DELETE WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED AND (s.a > 200) THEN INSERT DEFAULT VALUES WHEN NOT MATCHED AND (s.a > 100) THEN INSERT (id, data) OVERRIDING USER VALUE VALUES (s.a, DEFAULT) WHEN NOT MATCHED AND (s.a > 0) THEN INSERT (id, data, filling) VALUES (s.a, s.b, DEFAULT) WHEN NOT MATCHED THEN INSERT (filling[1], id) VALUES (s.a, s.a) RETURNING MERGE_ACTION() AS action, s.a, s.b, t.id, t.data, t.filling; END DROP FUNCTION merge_sf_test; DROP TABLE sf_target; -- -- Test enabling/disabling -- CREATE TABLE ruletest1 (a int); CREATE TABLE ruletest2 (b int); CREATE RULE rule1 AS ON INSERT TO ruletest1 DO INSTEAD INSERT INTO ruletest2 VALUES (NEW.*); INSERT INTO ruletest1 VALUES (1); ALTER TABLE ruletest1 DISABLE RULE rule1; INSERT INTO ruletest1 VALUES (2); ALTER TABLE ruletest1 ENABLE RULE rule1; SET session_replication_role = replica; INSERT INTO ruletest1 VALUES (3); ALTER TABLE ruletest1 ENABLE REPLICA RULE rule1; INSERT INTO ruletest1 VALUES (4); RESET session_replication_role; INSERT INTO ruletest1 VALUES (5); SELECT * FROM ruletest1; a --- 2 3 5 (3 rows) SELECT * FROM ruletest2; b --- 1 4 (2 rows) DROP TABLE ruletest1; DROP TABLE ruletest2; -- -- Test non-SELECT rule on security invoker view. -- Should use view owner's permissions. -- CREATE USER regress_rule_user1; CREATE TABLE ruletest_t1 (x int); CREATE TABLE ruletest_t2 (x int); CREATE VIEW ruletest_v1 WITH (security_invoker=true) AS SELECT * FROM ruletest_t1; GRANT INSERT ON ruletest_v1 TO regress_rule_user1; CREATE RULE rule1 AS ON INSERT TO ruletest_v1 DO INSTEAD INSERT INTO ruletest_t2 VALUES (NEW.*); SET SESSION AUTHORIZATION regress_rule_user1; INSERT INTO ruletest_v1 VALUES (1); RESET SESSION AUTHORIZATION; -- Test that main query's relation's permissions are checked before -- the rule action's relation's. CREATE TABLE ruletest_t3 (x int); CREATE RULE rule2 AS ON UPDATE TO ruletest_t1 DO INSTEAD INSERT INTO ruletest_t2 VALUES (OLD.*); REVOKE ALL ON ruletest_t2 FROM regress_rule_user1; REVOKE ALL ON ruletest_t3 FROM regress_rule_user1; ALTER TABLE ruletest_t1 OWNER TO regress_rule_user1; SET SESSION AUTHORIZATION regress_rule_user1; UPDATE ruletest_t1 t1 SET x = 0 FROM ruletest_t3 t3 WHERE t1.x = t3.x; ERROR: permission denied for table ruletest_t3 RESET SESSION AUTHORIZATION; SELECT * FROM ruletest_t1; x --- (0 rows) SELECT * FROM ruletest_t2; x --- 1 (1 row) DROP VIEW ruletest_v1; DROP RULE rule2 ON ruletest_t1; DROP TABLE ruletest_t3; DROP TABLE ruletest_t2; DROP TABLE ruletest_t1; DROP USER regress_rule_user1;