Adding upstream version 14.5.upstream/14.5upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3701 insertions, 0 deletions

diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
new file mode 100644
index 0000000..2fa00a3
--- /dev/null
+++ b/src/test/regress/expected/rules.out
@@ -0,0 +1,3701 @@
+--
+-- 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 money);
+create table rtest_emplog (ename char(20), who name, action char(10), newsal money, oldsal money);
+create table rtest_empmass (ename char(20), salary money);
+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 | $80,000.00
+ gates                | t            | hired      | $80,000.00 |      $0.00
+ wiecc                | t            | hired      |  $5,000.00 |      $0.00
+ wieck                | t            | honored    |  $6,000.00 |  $5,000.00
+ wieck                | t            | honored    |  $7,000.00 |  $6,000.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 | $80,000.00
+ gates                | t            | hired      | $80,000.00 |      $0.00
+ maier                | t            | hired      |  $5,000.00 |      $0.00
+ mayr                 | t            | hired      |  $6,000.00 |      $0.00
+ meyer                | t            | hired      |  $4,000.00 |      $0.00
+ wiecc                | t            | hired      |  $5,000.00 |      $0.00
+ wieck                | t            | honored    |  $6,000.00 |  $5,000.00
+ wieck                | t            | honored    |  $7,000.00 |  $6,000.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 | $80,000.00
+ gates                | t            | hired      | $80,000.00 |      $0.00
+ maier                | t            | hired      |  $5,000.00 |      $0.00
+ maier                | t            | honored    |  $6,000.00 |  $5,000.00
+ mayr                 | t            | hired      |  $6,000.00 |      $0.00
+ mayr                 | t            | honored    |  $7,000.00 |  $6,000.00
+ meyer                | t            | hired      |  $4,000.00 |      $0.00
+ meyer                | t            | honored    |  $5,000.00 |  $4,000.00
+ wiecc                | t            | hired      |  $5,000.00 |      $0.00
+ wieck                | t            | honored    |  $6,000.00 |  $5,000.00
+ wieck                | t            | honored    |  $7,000.00 |  $6,000.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 | $80,000.00
+ gates                | t            | hired      | $80,000.00 |      $0.00
+ maier                | t            | fired      |      $0.00 |  $6,000.00
+ maier                | t            | hired      |  $5,000.00 |      $0.00
+ maier                | t            | honored    |  $6,000.00 |  $5,000.00
+ mayr                 | t            | fired      |      $0.00 |  $7,000.00
+ mayr                 | t            | hired      |  $6,000.00 |      $0.00
+ mayr                 | t            | honored    |  $7,000.00 |  $6,000.00
+ meyer                | t            | fired      |      $0.00 |  $5,000.00
+ meyer                | t            | hired      |  $4,000.00 |      $0.00
+ meyer                | t            | honored    |  $5,000.00 |  $4,000.00
+ wiecc                | t            | hired      |  $5,000.00 |      $0.00
+ wieck                | t            | honored    |  $6,000.00 |  $5,000.00
+ wieck                | t            | honored    |  $7,000.00 |  $6,000.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);
+                                                  ^
+HINT:  There is a column named "f1" in table "old", but it cannot be referenced from this part of the query.
+-- 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 IN ('pg_catalog', 'public')
+ORDER BY viewname;
+iexit| SELECT ih.name,
+    ih.thepath,
+    interpt_pp(ih.thepath, r.thepath) AS exit
+   FROM ihighway ih,
+    ramp r
+  WHERE (ih.thepath ## r.thepath);
+key_dependent_view| SELECT view_base_table.key,
+    view_base_table.data
+   FROM view_base_table
+  GROUP BY view_base_table.key;
+key_dependent_view_no_cols| SELECT
+   FROM view_base_table
+  GROUP BY view_base_table.key
+ HAVING (length((view_base_table.data)::text) > 0);
+mvtest_tv| SELECT mvtest_t.type,
+    sum(mvtest_t.amt) AS totamt
+   FROM mvtest_t
+  GROUP BY mvtest_t.type;
+mvtest_tvv| SELECT sum(mvtest_tv.totamt) AS grandtot
+   FROM mvtest_tv;
+mvtest_tvvmv| SELECT mvtest_tvvm.grandtot
+   FROM mvtest_tvvm;
+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 pg_get_backend_memory_contexts.name,
+    pg_get_backend_memory_contexts.ident,
+    pg_get_backend_memory_contexts.parent,
+    pg_get_backend_memory_contexts.level,
+    pg_get_backend_memory_contexts.total_bytes,
+    pg_get_backend_memory_contexts.total_nblocks,
+    pg_get_backend_memory_contexts.free_bytes,
+    pg_get_backend_memory_contexts.free_chunks,
+    pg_get_backend_memory_contexts.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 pg_config.name,
+    pg_config.setting
+   FROM pg_config() pg_config(name, setting);
+pg_cursors| SELECT c.name,
+    c.statement,
+    c.is_holdable,
+    c.is_binary,
+    c.is_scrollable,
+    c.creation_time
+   FROM pg_cursor() c(name, statement, is_holdable, is_binary, is_scrollable, creation_time);
+pg_file_settings| SELECT a.sourcefile,
+    a.sourceline,
+    a.seqno,
+    a.name,
+    a.setting,
+    a.applied,
+    a.error
+   FROM pg_show_all_file_settings() a(sourcefile, sourceline, seqno, name, setting, applied, error);
+pg_group| SELECT pg_authid.rolname AS groname,
+    pg_authid.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 pg_authid.rolcanlogin);
+pg_hba_file_rules| SELECT a.line_number,
+    a.type,
+    a.database,
+    a.user_name,
+    a.address,
+    a.netmask,
+    a.auth_method,
+    a.options,
+    a.error
+   FROM pg_hba_file_rules() a(line_number, type, database, user_name, address, netmask, auth_method, options, 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 l.locktype,
+    l.database,
+    l.relation,
+    l.page,
+    l.tuple,
+    l.virtualxid,
+    l.transactionid,
+    l.classid,
+    l.objid,
+    l.objsubid,
+    l.virtualtransaction,
+    l.pid,
+    l.mode,
+    l.granted,
+    l.fastpath,
+    l.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 p.name,
+    p.statement,
+    p.prepare_time,
+    p.parameter_types,
+    p.from_sql,
+    p.generic_plans,
+    p.custom_plans
+   FROM pg_prepared_statement() p(name, statement, prepare_time, parameter_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
+   FROM pg_publication p,
+    LATERAL pg_get_publication_tables((p.pubname)::text) gpt(relid),
+    (pg_class c
+     JOIN pg_namespace n ON ((n.oid = c.relnamespace)))
+  WHERE (c.oid = gpt.relid);
+pg_replication_origin_status| SELECT pg_show_replication_origin_status.local_id,
+    pg_show_replication_origin_status.external_id,
+    pg_show_replication_origin_status.remote_lsn,
+    pg_show_replication_origin_status.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
+   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)
+     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 a.name,
+    a.setting,
+    a.unit,
+    a.category,
+    a.short_desc,
+    a.extra_desc,
+    a.context,
+    a.vartype,
+    a.source,
+    a.min_val,
+    a.max_val,
+    a.enumvals,
+    a.boot_val,
+    a.reset_val,
+    a.sourcefile,
+    a.sourceline,
+    a.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 pg_get_shmem_allocations.name,
+    pg_get_shmem_allocations.off,
+    pg_get_shmem_allocations.size,
+    pg_get_shmem_allocations.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, 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_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_tuples_returned(c.oid) AS seq_tup_read,
+    (sum(pg_stat_get_numscans(i.indexrelid)))::bigint AS 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_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 s.archived_count,
+    s.last_archived_wal,
+    s.last_archived_time,
+    s.failed_count,
+    s.last_failed_wal,
+    s.last_failed_time,
+    s.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_timed_checkpoints() AS checkpoints_timed,
+    pg_stat_get_bgwriter_requested_checkpoints() AS checkpoints_req,
+    pg_stat_get_checkpoint_write_time() AS checkpoint_write_time,
+    pg_stat_get_checkpoint_sync_time() AS checkpoint_sync_time,
+    pg_stat_get_bgwriter_buf_written_checkpoints() AS buffers_checkpoint,
+    pg_stat_get_bgwriter_buf_written_clean() AS buffers_clean,
+    pg_stat_get_bgwriter_maxwritten_clean() AS maxwritten_clean,
+    pg_stat_get_buf_written_backend() AS buffers_backend,
+    pg_stat_get_buf_fsync_backend() AS buffers_backend_fsync,
+    pg_stat_get_buf_alloc() AS buffers_alloc,
+    pg_stat_get_bgwriter_stat_reset_time() AS stats_reset;
+pg_stat_database| SELECT d.oid AS datid,
+    d.datname,
+        CASE
+            WHEN (d.oid = (0)::oid) THEN 0
+            ELSE pg_stat_get_db_numbackends(d.oid)
+        END AS numbackends,
+    pg_stat_get_db_xact_commit(d.oid) AS xact_commit,
+    pg_stat_get_db_xact_rollback(d.oid) AS xact_rollback,
+    (pg_stat_get_db_blocks_fetched(d.oid) - pg_stat_get_db_blocks_hit(d.oid)) AS blks_read,
+    pg_stat_get_db_blocks_hit(d.oid) AS blks_hit,
+    pg_stat_get_db_tuples_returned(d.oid) AS tup_returned,
+    pg_stat_get_db_tuples_fetched(d.oid) AS tup_fetched,
+    pg_stat_get_db_tuples_inserted(d.oid) AS tup_inserted,
+    pg_stat_get_db_tuples_updated(d.oid) AS tup_updated,
+    pg_stat_get_db_tuples_deleted(d.oid) AS tup_deleted,
+    pg_stat_get_db_conflict_all(d.oid) AS conflicts,
+    pg_stat_get_db_temp_files(d.oid) AS temp_files,
+    pg_stat_get_db_temp_bytes(d.oid) AS temp_bytes,
+    pg_stat_get_db_deadlocks(d.oid) AS deadlocks,
+    pg_stat_get_db_checksum_failures(d.oid) AS checksum_failures,
+    pg_stat_get_db_checksum_last_failure(d.oid) AS checksum_last_failure,
+    pg_stat_get_db_blk_read_time(d.oid) AS blk_read_time,
+    pg_stat_get_db_blk_write_time(d.oid) AS blk_write_time,
+    pg_stat_get_db_session_time(d.oid) AS session_time,
+    pg_stat_get_db_active_time(d.oid) AS active_time,
+    pg_stat_get_db_idle_in_transaction_time(d.oid) AS idle_in_transaction_time,
+    pg_stat_get_db_sessions(d.oid) AS sessions,
+    pg_stat_get_db_sessions_abandoned(d.oid) AS sessions_abandoned,
+    pg_stat_get_db_sessions_fatal(d.oid) AS sessions_fatal,
+    pg_stat_get_db_sessions_killed(d.oid) AS sessions_killed,
+    pg_stat_get_db_stat_reset_time(d.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 d.oid AS datid,
+    d.datname,
+    pg_stat_get_db_conflict_tablespace(d.oid) AS confl_tablespace,
+    pg_stat_get_db_conflict_lock(d.oid) AS confl_lock,
+    pg_stat_get_db_conflict_snapshot(d.oid) AS confl_snapshot,
+    pg_stat_get_db_conflict_bufferpin(d.oid) AS confl_bufferpin,
+    pg_stat_get_db_conflict_startup_deadlock(d.oid) AS confl_deadlock
+   FROM pg_database d;
+pg_stat_gssapi| SELECT s.pid,
+    s.gss_auth AS gss_authenticated,
+    s.gss_princ AS principal,
+    s.gss_enc AS encrypted
+   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, leader_pid, query_id)
+  WHERE (s.client_port IS NOT NULL);
+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 s.pid,
+        CASE s.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 s.param2
+            WHEN '-1'::integer THEN NULL::bigint
+            ELSE s.param2
+        END AS backup_total,
+    s.param3 AS backup_streamed,
+    s.param4 AS tablespaces_total,
+    s.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
+   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
+   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_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, 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 s.name,
+    s.blks_zeroed,
+    s.blks_hit,
+    s.blks_read,
+    s.blks_written,
+    s.blks_exists,
+    s.flushes,
+    s.truncates,
+    s.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 s.pid,
+    s.ssl,
+    s.sslversion AS version,
+    s.sslcipher AS cipher,
+    s.sslbits AS bits,
+    s.ssl_client_dn AS client_dn,
+    s.ssl_client_serial AS client_serial,
+    s.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, leader_pid, query_id)
+  WHERE (s.client_port IS NOT NULL);
+pg_stat_subscription| SELECT su.oid AS subid,
+    su.subname,
+    st.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, received_lsn, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time) ON ((st.subid = su.oid)));
+pg_stat_sys_indexes| SELECT pg_stat_all_indexes.relid,
+    pg_stat_all_indexes.indexrelid,
+    pg_stat_all_indexes.schemaname,
+    pg_stat_all_indexes.relname,
+    pg_stat_all_indexes.indexrelname,
+    pg_stat_all_indexes.idx_scan,
+    pg_stat_all_indexes.idx_tup_read,
+    pg_stat_all_indexes.idx_tup_fetch
+   FROM pg_stat_all_indexes
+  WHERE ((pg_stat_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_stat_all_indexes.schemaname ~ '^pg_toast'::text));
+pg_stat_sys_tables| SELECT pg_stat_all_tables.relid,
+    pg_stat_all_tables.schemaname,
+    pg_stat_all_tables.relname,
+    pg_stat_all_tables.seq_scan,
+    pg_stat_all_tables.seq_tup_read,
+    pg_stat_all_tables.idx_scan,
+    pg_stat_all_tables.idx_tup_fetch,
+    pg_stat_all_tables.n_tup_ins,
+    pg_stat_all_tables.n_tup_upd,
+    pg_stat_all_tables.n_tup_del,
+    pg_stat_all_tables.n_tup_hot_upd,
+    pg_stat_all_tables.n_live_tup,
+    pg_stat_all_tables.n_dead_tup,
+    pg_stat_all_tables.n_mod_since_analyze,
+    pg_stat_all_tables.n_ins_since_vacuum,
+    pg_stat_all_tables.last_vacuum,
+    pg_stat_all_tables.last_autovacuum,
+    pg_stat_all_tables.last_analyze,
+    pg_stat_all_tables.last_autoanalyze,
+    pg_stat_all_tables.vacuum_count,
+    pg_stat_all_tables.autovacuum_count,
+    pg_stat_all_tables.analyze_count,
+    pg_stat_all_tables.autoanalyze_count
+   FROM pg_stat_all_tables
+  WHERE ((pg_stat_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_stat_all_tables.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 pg_stat_all_indexes.relid,
+    pg_stat_all_indexes.indexrelid,
+    pg_stat_all_indexes.schemaname,
+    pg_stat_all_indexes.relname,
+    pg_stat_all_indexes.indexrelname,
+    pg_stat_all_indexes.idx_scan,
+    pg_stat_all_indexes.idx_tup_read,
+    pg_stat_all_indexes.idx_tup_fetch
+   FROM pg_stat_all_indexes
+  WHERE ((pg_stat_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_stat_all_indexes.schemaname !~ '^pg_toast'::text));
+pg_stat_user_tables| SELECT pg_stat_all_tables.relid,
+    pg_stat_all_tables.schemaname,
+    pg_stat_all_tables.relname,
+    pg_stat_all_tables.seq_scan,
+    pg_stat_all_tables.seq_tup_read,
+    pg_stat_all_tables.idx_scan,
+    pg_stat_all_tables.idx_tup_fetch,
+    pg_stat_all_tables.n_tup_ins,
+    pg_stat_all_tables.n_tup_upd,
+    pg_stat_all_tables.n_tup_del,
+    pg_stat_all_tables.n_tup_hot_upd,
+    pg_stat_all_tables.n_live_tup,
+    pg_stat_all_tables.n_dead_tup,
+    pg_stat_all_tables.n_mod_since_analyze,
+    pg_stat_all_tables.n_ins_since_vacuum,
+    pg_stat_all_tables.last_vacuum,
+    pg_stat_all_tables.last_autovacuum,
+    pg_stat_all_tables.last_analyze,
+    pg_stat_all_tables.last_autoanalyze,
+    pg_stat_all_tables.vacuum_count,
+    pg_stat_all_tables.autovacuum_count,
+    pg_stat_all_tables.analyze_count,
+    pg_stat_all_tables.autoanalyze_count
+   FROM pg_stat_all_tables
+  WHERE ((pg_stat_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_stat_all_tables.schemaname !~ '^pg_toast'::text));
+pg_stat_wal| SELECT w.wal_records,
+    w.wal_fpi,
+    w.wal_bytes,
+    w.wal_buffers_full,
+    w.wal_write,
+    w.wal_sync,
+    w.wal_write_time,
+    w.wal_sync_time,
+    w.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 s.pid,
+    s.status,
+    s.receive_start_lsn,
+    s.receive_start_tli,
+    s.written_lsn,
+    s.flushed_lsn,
+    s.received_tli,
+    s.last_msg_send_time,
+    s.last_msg_receipt_time,
+    s.latest_end_lsn,
+    s.latest_end_time,
+    s.slot_name,
+    s.sender_host,
+    s.sender_port,
+    s.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 (s.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
+   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 pg_stat_xact_all_tables.relid,
+    pg_stat_xact_all_tables.schemaname,
+    pg_stat_xact_all_tables.relname,
+    pg_stat_xact_all_tables.seq_scan,
+    pg_stat_xact_all_tables.seq_tup_read,
+    pg_stat_xact_all_tables.idx_scan,
+    pg_stat_xact_all_tables.idx_tup_fetch,
+    pg_stat_xact_all_tables.n_tup_ins,
+    pg_stat_xact_all_tables.n_tup_upd,
+    pg_stat_xact_all_tables.n_tup_del,
+    pg_stat_xact_all_tables.n_tup_hot_upd
+   FROM pg_stat_xact_all_tables
+  WHERE ((pg_stat_xact_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_stat_xact_all_tables.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 pg_stat_xact_all_tables.relid,
+    pg_stat_xact_all_tables.schemaname,
+    pg_stat_xact_all_tables.relname,
+    pg_stat_xact_all_tables.seq_scan,
+    pg_stat_xact_all_tables.seq_tup_read,
+    pg_stat_xact_all_tables.idx_scan,
+    pg_stat_xact_all_tables.idx_tup_fetch,
+    pg_stat_xact_all_tables.n_tup_ins,
+    pg_stat_xact_all_tables.n_tup_upd,
+    pg_stat_xact_all_tables.n_tup_del,
+    pg_stat_xact_all_tables.n_tup_hot_upd
+   FROM pg_stat_xact_all_tables
+  WHERE ((pg_stat_xact_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_stat_xact_all_tables.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,
+    (sum((pg_stat_get_blocks_fetched(i.indexrelid) - pg_stat_get_blocks_hit(i.indexrelid))))::bigint AS idx_blks_read,
+    (sum(pg_stat_get_blocks_hit(i.indexrelid)))::bigint AS 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,
+    (pg_stat_get_blocks_fetched(x.indexrelid) - pg_stat_get_blocks_hit(x.indexrelid)) AS tidx_blks_read,
+    pg_stat_get_blocks_hit(x.indexrelid) AS tidx_blks_hit
+   FROM ((((pg_class c
+     LEFT JOIN pg_index i ON ((c.oid = i.indrelid)))
+     LEFT JOIN pg_class t ON ((c.reltoastrelid = t.oid)))
+     LEFT JOIN pg_index x ON ((t.oid = x.indrelid)))
+     LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))
+  WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char"]))
+  GROUP BY c.oid, n.nspname, c.relname, t.oid, x.indexrelid;
+pg_statio_sys_indexes| SELECT pg_statio_all_indexes.relid,
+    pg_statio_all_indexes.indexrelid,
+    pg_statio_all_indexes.schemaname,
+    pg_statio_all_indexes.relname,
+    pg_statio_all_indexes.indexrelname,
+    pg_statio_all_indexes.idx_blks_read,
+    pg_statio_all_indexes.idx_blks_hit
+   FROM pg_statio_all_indexes
+  WHERE ((pg_statio_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_statio_all_indexes.schemaname ~ '^pg_toast'::text));
+pg_statio_sys_sequences| SELECT pg_statio_all_sequences.relid,
+    pg_statio_all_sequences.schemaname,
+    pg_statio_all_sequences.relname,
+    pg_statio_all_sequences.blks_read,
+    pg_statio_all_sequences.blks_hit
+   FROM pg_statio_all_sequences
+  WHERE ((pg_statio_all_sequences.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_statio_all_sequences.schemaname ~ '^pg_toast'::text));
+pg_statio_sys_tables| SELECT pg_statio_all_tables.relid,
+    pg_statio_all_tables.schemaname,
+    pg_statio_all_tables.relname,
+    pg_statio_all_tables.heap_blks_read,
+    pg_statio_all_tables.heap_blks_hit,
+    pg_statio_all_tables.idx_blks_read,
+    pg_statio_all_tables.idx_blks_hit,
+    pg_statio_all_tables.toast_blks_read,
+    pg_statio_all_tables.toast_blks_hit,
+    pg_statio_all_tables.tidx_blks_read,
+    pg_statio_all_tables.tidx_blks_hit
+   FROM pg_statio_all_tables
+  WHERE ((pg_statio_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_statio_all_tables.schemaname ~ '^pg_toast'::text));
+pg_statio_user_indexes| SELECT pg_statio_all_indexes.relid,
+    pg_statio_all_indexes.indexrelid,
+    pg_statio_all_indexes.schemaname,
+    pg_statio_all_indexes.relname,
+    pg_statio_all_indexes.indexrelname,
+    pg_statio_all_indexes.idx_blks_read,
+    pg_statio_all_indexes.idx_blks_hit
+   FROM pg_statio_all_indexes
+  WHERE ((pg_statio_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_statio_all_indexes.schemaname !~ '^pg_toast'::text));
+pg_statio_user_sequences| SELECT pg_statio_all_sequences.relid,
+    pg_statio_all_sequences.schemaname,
+    pg_statio_all_sequences.relname,
+    pg_statio_all_sequences.blks_read,
+    pg_statio_all_sequences.blks_hit
+   FROM pg_statio_all_sequences
+  WHERE ((pg_statio_all_sequences.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_statio_all_sequences.schemaname !~ '^pg_toast'::text));
+pg_statio_user_tables| SELECT pg_statio_all_tables.relid,
+    pg_statio_all_tables.schemaname,
+    pg_statio_all_tables.relname,
+    pg_statio_all_tables.heap_blks_read,
+    pg_statio_all_tables.heap_blks_hit,
+    pg_statio_all_tables.idx_blks_read,
+    pg_statio_all_tables.idx_blks_hit,
+    pg_statio_all_tables.toast_blks_read,
+    pg_statio_all_tables.toast_blks_hit,
+    pg_statio_all_tables.tidx_blks_read,
+    pg_statio_all_tables.tidx_blks_hit
+   FROM pg_statio_all_tables
+  WHERE ((pg_statio_all_tables.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_statio_all_tables.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
+   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.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,
+    (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 pg_timezone_abbrevs.abbrev,
+    pg_timezone_abbrevs.utc_offset,
+    pg_timezone_abbrevs.is_dst
+   FROM pg_timezone_abbrevs() pg_timezone_abbrevs(abbrev, utc_offset, is_dst);
+pg_timezone_names| SELECT pg_timezone_names.name,
+    pg_timezone_names.abbrev,
+    pg_timezone_names.utc_offset,
+    pg_timezone_names.is_dst
+   FROM pg_timezone_names() pg_timezone_names(name, abbrev, utc_offset, is_dst);
+pg_user| SELECT pg_shadow.usename,
+    pg_shadow.usesysid,
+    pg_shadow.usecreatedb,
+    pg_shadow.usesuper,
+    pg_shadow.userepl,
+    pg_shadow.usebypassrls,
+    '********'::text AS passwd,
+    pg_shadow.valuntil,
+    pg_shadow.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");
+rtest_v1| SELECT rtest_t1.a,
+    rtest_t1.b
+   FROM rtest_t1;
+rtest_vcomp| SELECT x.part,
+    (x.size * y.factor) AS size_in_cm
+   FROM rtest_comp x,
+    rtest_unitfact y
+  WHERE (x.unit = y.unit);
+rtest_vview1| SELECT x.a,
+    x.b
+   FROM rtest_view1 x
+  WHERE (0 < ( SELECT count(*) AS count
+           FROM rtest_view2 y
+          WHERE (y.a = x.a)));
+rtest_vview2| SELECT rtest_view1.a,
+    rtest_view1.b
+   FROM rtest_view1
+  WHERE rtest_view1.v;
+rtest_vview3| SELECT x.a,
+    x.b
+   FROM rtest_vview2 x
+  WHERE (0 < ( SELECT count(*) AS count
+           FROM rtest_view2 y
+          WHERE (y.a = x.a)));
+rtest_vview4| 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;
+rtest_vview5| SELECT rtest_view1.a,
+    rtest_view1.b,
+    rtest_viewfunc1(rtest_view1.a) AS refcount
+   FROM rtest_view1;
+shoe| 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);
+shoe_ready| 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));
+shoelace| 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);
+shoelace_candelete| SELECT shoelace_obsolete.sl_name,
+    shoelace_obsolete.sl_avail,
+    shoelace_obsolete.sl_color,
+    shoelace_obsolete.sl_len,
+    shoelace_obsolete.sl_unit,
+    shoelace_obsolete.sl_len_cm
+   FROM shoelace_obsolete
+  WHERE (shoelace_obsolete.sl_avail = 0);
+shoelace_obsolete| SELECT shoelace.sl_name,
+    shoelace.sl_avail,
+    shoelace.sl_color,
+    shoelace.sl_len,
+    shoelace.sl_unit,
+    shoelace.sl_len_cm
+   FROM shoelace
+  WHERE (NOT (EXISTS ( SELECT shoe.shoename
+           FROM shoe
+          WHERE (shoe.slcolor = shoelace.sl_color))));
+street| SELECT r.name,
+    r.thepath,
+    c.cname
+   FROM ONLY road r,
+    real_city c
+  WHERE (c.outline ## r.thepath);
+test_tablesample_v1| SELECT test_tablesample.id
+   FROM test_tablesample TABLESAMPLE system ((10 * 2)) REPEATABLE (2);
+test_tablesample_v2| SELECT test_tablesample.id
+   FROM test_tablesample TABLESAMPLE system (99);
+toyemp| SELECT emp.name,
+    emp.age,
+    emp.location,
+    (12 * emp.salary) AS annualsal
+   FROM emp;
+SELECT tablename, rulename, definition FROM pg_rules
+WHERE schemaname IN ('pg_catalog', 'public')
+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;
+rtest_emp|rtest_emp_del|CREATE RULE rtest_emp_del AS
+    ON DELETE TO public.rtest_emp DO  INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal)
+  VALUES (old.ename, CURRENT_USER, 'fired'::bpchar, '$0.00'::money, old.salary);
+rtest_emp|rtest_emp_ins|CREATE RULE rtest_emp_ins AS
+    ON INSERT TO public.rtest_emp DO  INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal)
+  VALUES (new.ename, CURRENT_USER, 'hired'::bpchar, new.salary, '$0.00'::money);
+rtest_emp|rtest_emp_upd|CREATE RULE rtest_emp_upd AS
+    ON UPDATE TO public.rtest_emp
+   WHERE (new.salary <> old.salary) DO  INSERT INTO rtest_emplog (ename, who, action, newsal, oldsal)
+  VALUES (new.ename, CURRENT_USER, 'honored'::bpchar, new.salary, old.salary);
+rtest_nothn1|rtest_nothn_r1|CREATE RULE rtest_nothn_r1 AS
+    ON INSERT TO public.rtest_nothn1
+   WHERE ((new.a >= 10) AND (new.a < 20)) DO INSTEAD NOTHING;
+rtest_nothn1|rtest_nothn_r2|CREATE RULE rtest_nothn_r2 AS
+    ON INSERT TO public.rtest_nothn1
+   WHERE ((new.a >= 30) AND (new.a < 40)) DO INSTEAD NOTHING;
+rtest_nothn2|rtest_nothn_r3|CREATE RULE rtest_nothn_r3 AS
+    ON INSERT TO public.rtest_nothn2
+   WHERE (new.a >= 100) DO INSTEAD  INSERT INTO rtest_nothn3 (a, b)
+  VALUES (new.a, new.b);
+rtest_nothn2|rtest_nothn_r4|CREATE RULE rtest_nothn_r4 AS
+    ON INSERT TO public.rtest_nothn2 DO INSTEAD NOTHING;
+rtest_order1|rtest_order_r1|CREATE RULE rtest_order_r1 AS
+    ON INSERT TO public.rtest_order1 DO INSTEAD  INSERT INTO rtest_order2 (a, b, c)
+  VALUES (new.a, nextval('rtest_seq'::regclass), 'rule 1 - this should run 1st'::text);
+rtest_order1|rtest_order_r2|CREATE RULE rtest_order_r2 AS
+    ON INSERT TO public.rtest_order1 DO  INSERT INTO rtest_order2 (a, b, c)
+  VALUES (new.a, nextval('rtest_seq'::regclass), 'rule 2 - this should run 2nd'::text);
+rtest_order1|rtest_order_r3|CREATE RULE rtest_order_r3 AS
+    ON INSERT TO public.rtest_order1 DO INSTEAD  INSERT INTO rtest_order2 (a, b, c)
+  VALUES (new.a, nextval('rtest_seq'::regclass), 'rule 3 - this should run 3rd'::text);
+rtest_order1|rtest_order_r4|CREATE RULE rtest_order_r4 AS
+    ON INSERT TO public.rtest_order1
+   WHERE (new.a < 100) DO INSTEAD  INSERT INTO rtest_order2 (a, b, c)
+  VALUES (new.a, nextval('rtest_seq'::regclass), 'rule 4 - this should run 4th'::text);
+rtest_person|rtest_pers_del|CREATE RULE rtest_pers_del AS
+    ON DELETE TO public.rtest_person DO  DELETE FROM rtest_admin
+  WHERE (rtest_admin.pname = old.pname);
+rtest_person|rtest_pers_upd|CREATE RULE rtest_pers_upd AS
+    ON UPDATE TO public.rtest_person DO  UPDATE rtest_admin SET pname = new.pname
+  WHERE (rtest_admin.pname = old.pname);
+rtest_system|rtest_sys_del|CREATE RULE rtest_sys_del AS
+    ON DELETE TO public.rtest_system DO ( DELETE FROM rtest_interface
+  WHERE (rtest_interface.sysname = old.sysname);
+ DELETE FROM rtest_admin
+  WHERE (rtest_admin.sysname = old.sysname);
+);
+rtest_system|rtest_sys_upd|CREATE RULE rtest_sys_upd AS
+    ON UPDATE TO public.rtest_system DO ( UPDATE rtest_interface SET sysname = new.sysname
+  WHERE (rtest_interface.sysname = old.sysname);
+ UPDATE rtest_admin SET sysname = new.sysname
+  WHERE (rtest_admin.sysname = old.sysname);
+);
+rtest_t4|rtest_t4_ins1|CREATE RULE rtest_t4_ins1 AS
+    ON INSERT TO public.rtest_t4
+   WHERE ((new.a >= 10) AND (new.a < 20)) DO INSTEAD  INSERT INTO rtest_t5 (a, b)
+  VALUES (new.a, new.b);
+rtest_t4|rtest_t4_ins2|CREATE RULE rtest_t4_ins2 AS
+    ON INSERT TO public.rtest_t4
+   WHERE ((new.a >= 20) AND (new.a < 30)) DO  INSERT INTO rtest_t6 (a, b)
+  VALUES (new.a, new.b);
+rtest_t5|rtest_t5_ins|CREATE RULE rtest_t5_ins AS
+    ON INSERT TO public.rtest_t5
+   WHERE (new.a > 15) DO  INSERT INTO rtest_t7 (a, b)
+  VALUES (new.a, new.b);
+rtest_t6|rtest_t6_ins|CREATE RULE rtest_t6_ins AS
+    ON INSERT TO public.rtest_t6
+   WHERE (new.a > 25) DO INSTEAD  INSERT INTO rtest_t8 (a, b)
+  VALUES (new.a, new.b);
+rtest_v1|rtest_v1_del|CREATE RULE rtest_v1_del AS
+    ON DELETE TO public.rtest_v1 DO INSTEAD  DELETE FROM rtest_t1
+  WHERE (rtest_t1.a = old.a);
+rtest_v1|rtest_v1_ins|CREATE RULE rtest_v1_ins AS
+    ON INSERT TO public.rtest_v1 DO INSTEAD  INSERT INTO rtest_t1 (a, b)
+  VALUES (new.a, new.b);
+rtest_v1|rtest_v1_upd|CREATE RULE rtest_v1_upd AS
+    ON UPDATE TO public.rtest_v1 DO INSTEAD  UPDATE rtest_t1 SET a = new.a, b = new.b
+  WHERE (rtest_t1.a = old.a);
+shoelace|shoelace_del|CREATE RULE shoelace_del AS
+    ON DELETE TO public.shoelace DO INSTEAD  DELETE FROM shoelace_data
+  WHERE (shoelace_data.sl_name = old.sl_name);
+shoelace|shoelace_ins|CREATE RULE shoelace_ins AS
+    ON INSERT TO public.shoelace DO INSTEAD  INSERT INTO shoelace_data (sl_name, sl_avail, sl_color, sl_len, sl_unit)
+  VALUES (new.sl_name, new.sl_avail, new.sl_color, new.sl_len, new.sl_unit);
+shoelace|shoelace_upd|CREATE RULE shoelace_upd AS
+    ON UPDATE TO public.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 (shoelace_data.sl_name = old.sl_name);
+shoelace_data|log_shoelace|CREATE RULE log_shoelace AS
+    ON UPDATE TO public.shoelace_data
+   WHERE (new.sl_avail <> old.sl_avail) DO  INSERT INTO shoelace_log (sl_name, sl_avail, log_who, log_when)
+  VALUES (new.sl_name, new.sl_avail, 'Al Bundy'::name, 'Thu Jan 01 00:00:00 1970'::timestamp without time zone);
+shoelace_ok|shoelace_ok_ins|CREATE RULE shoelace_ok_ins AS
+    ON INSERT TO public.shoelace_ok DO INSTEAD  UPDATE shoelace SET sl_avail = (shoelace.sl_avail + new.ok_quant)
+  WHERE (shoelace.sl_name = new.ok_name);
+-- 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;
+--
+-- test conversion of table to view (needed to load some pg_dump files)
+--
+create table rules_fooview (x int, y text);
+select xmin, * from rules_fooview;
+ xmin | x | y 
+------+---+---
+(0 rows)
+
+create rule "_RETURN" as on select to rules_fooview do instead
+  select 1 as x, 'aaa'::text as y;
+select * from rules_fooview;
+ x |  y  
+---+-----
+ 1 | aaa
+(1 row)
+
+select xmin, * from rules_fooview;  -- fail, views don't have such a column
+ERROR:  column "xmin" does not exist
+LINE 1: select xmin, * from rules_fooview;
+               ^
+select reltoastrelid, relkind, relfrozenxid
+  from pg_class where oid = 'rules_fooview'::regclass;
+ reltoastrelid | relkind | relfrozenxid 
+---------------+---------+--------------
+             0 | v       |            0
+(1 row)
+
+drop view rules_fooview;
+-- cannot convert an inheritance parent or child to a view, though
+create table rules_fooview (x int, y text);
+create table rules_fooview_child () inherits (rules_fooview);
+create rule "_RETURN" as on select to rules_fooview do instead
+  select 1 as x, 'aaa'::text as y;
+ERROR:  could not convert table "rules_fooview" to a view because it has child tables
+create rule "_RETURN" as on select to rules_fooview_child do instead
+  select 1 as x, 'aaa'::text as y;
+ERROR:  could not convert table "rules_fooview_child" to a view because it has parent tables
+drop table rules_fooview cascade;
+NOTICE:  drop cascades to table rules_fooview_child
+-- 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:  cannot convert partitioned table "rules_fooview" to a view
+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:  cannot convert partition "rules_fooview_part" to a view
+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);
+create table rules_log(f1 int, f2 int, tag text);
+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'), (new.*, 'new');
+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 
+----+-----+-----
+  1 |   2 | old
+  1 |   3 | new
+ 11 |  12 | old
+ 11 |  13 | new
+  1 |   3 | old
+  1 |  30 | new
+ 11 |  13 | old
+ 11 | 130 | new
+(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)
+
+select * from rules_src;
+ f1 | f2 
+----+----
+  1 |  3
+ 11 | 13
+(2 rows)
+
+select * from rules_log;
+ f1 | f2  | tag 
+----+-----+-----
+  1 |   2 | old
+  1 |   3 | new
+ 11 |  12 | old
+ 11 |  13 | new
+  1 |   3 | old
+  1 |  30 | new
+ 11 |  13 | old
+ 11 | 130 | new
+  1 |  30 | old
+  1 |   3 | new
+ 11 | 130 | old
+ 11 |  13 | new
+(12 rows)
+
+create rule r3 as on delete to rules_src do notify rules_src_deletion;
+\d+ rules_src
+                                 Table "public.rules_src"
+ Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description 
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ f1     | integer |           |          |         | plain   |              | 
+ f2     | integer |           |          |         | plain   |              | 
+Rules:
+    r1 AS
+    ON UPDATE TO rules_src DO  INSERT INTO rules_log (f1, f2, tag) VALUES (old.f1,old.f2,'old'::text), (new.f1,new.f2,'new'::text)
+    r2 AS
+    ON UPDATE TO rules_src DO  VALUES (old.f1,old.f2,'old'::text), (new.f1,new.f2,'new'::text)
+    r3 AS
+    ON DELETE TO rules_src DO
+ NOTIFY rules_src_deletion
+
+--
+-- Ensure an aliased target relation for insert is correctly deparsed.
+--
+create rule r4 as on insert to rules_src do instead insert into rules_log AS trgt SELECT NEW.* RETURNING trgt.f1, trgt.f2;
+create rule r5 as on update to rules_src do instead UPDATE rules_log AS trgt SET tag = 'updated' WHERE trgt.f1 = new.f1;
+\d+ rules_src
+                                 Table "public.rules_src"
+ Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description 
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ f1     | integer |           |          |         | plain   |              | 
+ f2     | integer |           |          |         | plain   |              | 
+Rules:
+    r1 AS
+    ON UPDATE TO rules_src DO  INSERT INTO rules_log (f1, f2, tag) VALUES (old.f1,old.f2,'old'::text), (new.f1,new.f2,'new'::text)
+    r2 AS
+    ON UPDATE TO rules_src DO  VALUES (old.f1,old.f2,'old'::text), (new.f1,new.f2,'new'::text)
+    r3 AS
+    ON DELETE TO rules_src DO
+ NOTIFY rules_src_deletion
+    r4 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
+    r5 AS
+    ON UPDATE TO rules_src DO INSTEAD  UPDATE rules_log trgt SET tag = 'updated'::text
+  WHERE trgt.f1 = new.f1
+
+--
+-- 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;
+--
+-- 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 rule_t1.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 "*VALUES*".column1,
+    "*VALUES*".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 "*VALUES*".column1 AS x,
+    "*VALUES*".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 v.column1 AS x,
+    v.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 v.q AS x,
+    v.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 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;