diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 38791865f61716e1e4655e18e02966a14b1d6458..92a79d350a4ead7030843acd1d259c7c29f52969 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -13872,8 +13872,7 @@ SELECT pg_type_is_visible('myschema.widget'::regtype);
       <row>
        <entry><literal><function>pg_get_viewdef(<parameter>view_name</parameter>, <parameter>pretty_bool</>)</function></literal></entry>
        <entry><type>text</type></entry>
-       <entry>get underlying <command>SELECT</command> command for view;
-              lines with fields are wrapped to 80 columns if <parameter>pretty_bool</parameter> is true (<emphasis>deprecated</emphasis>)</entry>
+       <entry>get underlying <command>SELECT</command> command for view (<emphasis>deprecated</emphasis>)</entry>
       </row>
       <row>
        <entry><literal><function>pg_get_viewdef(<parameter>view_oid</parameter>)</function></literal></entry>
@@ -13883,15 +13882,14 @@ SELECT pg_type_is_visible('myschema.widget'::regtype);
       <row>
        <entry><literal><function>pg_get_viewdef(<parameter>view_oid</parameter>, <parameter>pretty_bool</>)</function></literal></entry>
        <entry><type>text</type></entry>
-       <entry>get underlying <command>SELECT</command> command for view;
-              lines with fields are wrapped to 80 columns if <parameter>pretty_bool</parameter> is true</entry>
+       <entry>get underlying <command>SELECT</command> command for view</entry>
       </row>
       <row>
        <entry><literal><function>pg_get_viewdef(<parameter>view_oid</parameter>, <parameter>wrap_column_int</>)</function></literal></entry>
        <entry><type>text</type></entry>
        <entry>get underlying <command>SELECT</command> command for view;
               lines with fields are wrapped to specified number of columns,
-              pretty printing is implied</entry>
+              pretty-printing is implied</entry>
       </row>
       <row>
        <entry><literal><function>pg_options_to_table(<parameter>reloptions</parameter>)</function></literal></entry>
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 16f56c6adec43f6e5c7949b4e90d46012403ae95..af04b051601cf86a58b24a09844c1eb4093fdef4 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -74,8 +74,8 @@
 #define PRETTYFLAG_PAREN		1
 #define PRETTYFLAG_INDENT		2
 
-/* Default line length for pretty-print wrapping */
-#define WRAP_COLUMN_DEFAULT		79
+/* Default line length for pretty-print wrapping: 0 means wrap always */
+#define WRAP_COLUMN_DEFAULT		0
 
 /* macro to test if pretty action needed */
 #define PRETTY_PAREN(context)	((context)->prettyFlags & PRETTYFLAG_PAREN)
@@ -416,8 +416,10 @@ Datum
 pg_get_ruledef(PG_FUNCTION_ARGS)
 {
 	Oid			ruleoid = PG_GETARG_OID(0);
+	int			prettyFlags;
 
-	PG_RETURN_TEXT_P(string_to_text(pg_get_ruledef_worker(ruleoid, 0)));
+	prettyFlags = PRETTYFLAG_INDENT;
+	PG_RETURN_TEXT_P(string_to_text(pg_get_ruledef_worker(ruleoid, prettyFlags)));
 }
 
 
@@ -428,7 +430,7 @@ pg_get_ruledef_ext(PG_FUNCTION_ARGS)
 	bool		pretty = PG_GETARG_BOOL(1);
 	int			prettyFlags;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_ruledef_worker(ruleoid, prettyFlags)));
 }
 
@@ -512,8 +514,10 @@ pg_get_viewdef(PG_FUNCTION_ARGS)
 {
 	/* By OID */
 	Oid			viewoid = PG_GETARG_OID(0);
+	int			prettyFlags;
 
-	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, 0, -1)));
+	prettyFlags = PRETTYFLAG_INDENT;
+	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT)));
 }
 
 
@@ -525,7 +529,7 @@ pg_get_viewdef_ext(PG_FUNCTION_ARGS)
 	bool		pretty = PG_GETARG_BOOL(1);
 	int			prettyFlags;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT)));
 }
 
@@ -536,12 +540,10 @@ pg_get_viewdef_wrap(PG_FUNCTION_ARGS)
 	Oid			viewoid = PG_GETARG_OID(0);
 	int			wrap = PG_GETARG_INT32(1);
 	int			prettyFlags;
-	char	   *result;
 
 	/* calling this implies we want pretty printing */
 	prettyFlags = PRETTYFLAG_PAREN | PRETTYFLAG_INDENT;
-	result = pg_get_viewdef_worker(viewoid, prettyFlags, wrap);
-	PG_RETURN_TEXT_P(string_to_text(result));
+	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, wrap)));
 }
 
 Datum
@@ -549,14 +551,17 @@ pg_get_viewdef_name(PG_FUNCTION_ARGS)
 {
 	/* By qualified name */
 	text	   *viewname = PG_GETARG_TEXT_P(0);
+	int			prettyFlags;
 	RangeVar   *viewrel;
 	Oid			viewoid;
 
+	prettyFlags = PRETTYFLAG_INDENT;
+
 	/* Look up view name.  Can't lock it - we might not have privileges. */
 	viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
 	viewoid = RangeVarGetRelid(viewrel, NoLock, false);
 
-	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, 0, -1)));
+	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT)));
 }
 
 
@@ -570,7 +575,7 @@ pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
 	RangeVar   *viewrel;
 	Oid			viewoid;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 
 	/* Look up view name.  Can't lock it - we might not have privileges. */
 	viewrel = makeRangeVarFromNameList(textToQualifiedNameList(viewname));
@@ -848,7 +853,7 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
 		context.windowClause = NIL;
 		context.windowTList = NIL;
 		context.varprefix = true;
-		context.prettyFlags = pretty ? PRETTYFLAG_PAREN : 0;
+		context.prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 		context.wrapColumn = WRAP_COLUMN_DEFAULT;
 		context.indentLevel = PRETTYINDENT_STD;
 
@@ -911,10 +916,13 @@ Datum
 pg_get_indexdef(PG_FUNCTION_ARGS)
 {
 	Oid			indexrelid = PG_GETARG_OID(0);
+	int			prettyFlags;
 
+	prettyFlags = PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_indexdef_worker(indexrelid, 0,
 														   NULL,
-														   false, false, 0)));
+														   false, false,
+														   prettyFlags)));
 }
 
 Datum
@@ -925,7 +933,7 @@ pg_get_indexdef_ext(PG_FUNCTION_ARGS)
 	bool		pretty = PG_GETARG_BOOL(2);
 	int			prettyFlags;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_indexdef_worker(indexrelid, colno,
 														   NULL,
 														   colno != 0,
@@ -933,7 +941,7 @@ pg_get_indexdef_ext(PG_FUNCTION_ARGS)
 														   prettyFlags)));
 }
 
-/* Internal version that returns a palloc'd C string */
+/* Internal version that returns a palloc'd C string; no pretty-printing */
 char *
 pg_get_indexdef_string(Oid indexrelid)
 {
@@ -946,7 +954,7 @@ pg_get_indexdef_columns(Oid indexrelid, bool pretty)
 {
 	int			prettyFlags;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 	return pg_get_indexdef_worker(indexrelid, 0, NULL, true, false, prettyFlags);
 }
 
@@ -1245,9 +1253,12 @@ Datum
 pg_get_constraintdef(PG_FUNCTION_ARGS)
 {
 	Oid			constraintId = PG_GETARG_OID(0);
+	int			prettyFlags;
 
+	prettyFlags = PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_constraintdef_worker(constraintId,
-																false, 0)));
+																false,
+																prettyFlags)));
 }
 
 Datum
@@ -1257,12 +1268,13 @@ pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
 	bool		pretty = PG_GETARG_BOOL(1);
 	int			prettyFlags;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 	PG_RETURN_TEXT_P(string_to_text(pg_get_constraintdef_worker(constraintId,
-													   false, prettyFlags)));
+																false,
+																prettyFlags)));
 }
 
-/* Internal version that returns a palloc'd C string */
+/* Internal version that returns a palloc'd C string; no pretty-printing */
 char *
 pg_get_constraintdef_string(Oid constraintId)
 {
@@ -1615,8 +1627,11 @@ pg_get_expr(PG_FUNCTION_ARGS)
 {
 	text	   *expr = PG_GETARG_TEXT_P(0);
 	Oid			relid = PG_GETARG_OID(1);
+	int			prettyFlags;
 	char	   *relname;
 
+	prettyFlags = PRETTYFLAG_INDENT;
+
 	if (OidIsValid(relid))
 	{
 		/* Get the name for the relation */
@@ -1634,7 +1649,7 @@ pg_get_expr(PG_FUNCTION_ARGS)
 	else
 		relname = NULL;
 
-	PG_RETURN_TEXT_P(pg_get_expr_worker(expr, relid, relname, 0));
+	PG_RETURN_TEXT_P(pg_get_expr_worker(expr, relid, relname, prettyFlags));
 }
 
 Datum
@@ -1646,7 +1661,7 @@ pg_get_expr_ext(PG_FUNCTION_ARGS)
 	int			prettyFlags;
 	char	   *relname;
 
-	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : 0;
+	prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
 
 	if (OidIsValid(relid))
 	{
diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out
index 4c5b98a6126b9eee2b671006c250dd2c057bf49e..d379c0d7595337791221d1a856683b5c2048a786 100644
--- a/src/test/regress/expected/aggregates.out
+++ b/src/test/regress/expected/aggregates.out
@@ -943,9 +943,10 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                     pg_get_viewdef                                                                     
---------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(v.a, v.b, v.c) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
+                                                   pg_get_viewdef                                                    
+---------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(v.a, v.b, v.c) AS aggfns                                                                            +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
 (1 row)
 
 create or replace view agg_view1 as
@@ -959,9 +960,11 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                                       pg_get_viewdef                                                                                        
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(DISTINCT v.a, v.b, v.c) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), generate_series(1, 3) i(i);
+                                                    pg_get_viewdef                                                    
+----------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(DISTINCT v.a, v.b, v.c) AS aggfns                                                                    +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), +
+     generate_series(1, 3) i(i);
 (1 row)
 
 create or replace view agg_view1 as
@@ -975,9 +978,11 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                                              pg_get_viewdef                                                                                              
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(DISTINCT v.a, v.b, v.c ORDER BY v.b) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), generate_series(1, 3) i(i);
+                                                    pg_get_viewdef                                                    
+----------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(DISTINCT v.a, v.b, v.c ORDER BY v.b) AS aggfns                                                       +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), +
+     generate_series(1, 3) i(i);
 (1 row)
 
 create or replace view agg_view1 as
@@ -990,9 +995,10 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                              pg_get_viewdef                                                                               
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(v.a, v.b, v.c ORDER BY (v.b + 1)) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
+                                                   pg_get_viewdef                                                    
+---------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(v.a, v.b, v.c ORDER BY (v.b + 1)) AS aggfns                                                         +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
 (1 row)
 
 create or replace view agg_view1 as
@@ -1005,9 +1011,10 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                           pg_get_viewdef                                                                            
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(v.a, v.a, v.c ORDER BY v.b) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
+                                                   pg_get_viewdef                                                    
+---------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(v.a, v.a, v.c ORDER BY v.b) AS aggfns                                                               +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
 (1 row)
 
 create or replace view agg_view1 as
@@ -1020,9 +1027,10 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                                      pg_get_viewdef                                                                                      
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(v.a, v.b, v.c ORDER BY v.c USING ~<~ NULLS LAST) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
+                                                   pg_get_viewdef                                                    
+---------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(v.a, v.b, v.c ORDER BY v.c USING ~<~ NULLS LAST) AS aggfns                                          +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c);
 (1 row)
 
 create or replace view agg_view1 as
@@ -1036,9 +1044,11 @@ select * from agg_view1;
 (1 row)
 
 select pg_get_viewdef('agg_view1'::regclass);
-                                                                                                             pg_get_viewdef                                                                                                              
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- SELECT aggfns(DISTINCT v.a, v.b, v.c ORDER BY v.a, v.c USING ~<~ NULLS LAST, v.b) AS aggfns FROM (VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), generate_series(1, 2) i(i);
+                                                    pg_get_viewdef                                                    
+----------------------------------------------------------------------------------------------------------------------
+  SELECT aggfns(DISTINCT v.a, v.b, v.c ORDER BY v.a, v.c USING ~<~ NULLS LAST, v.b) AS aggfns                        +
+    FROM ( VALUES (1,3,'foo'::text), (0,NULL::integer,NULL::text), (2,2,'bar'::text), (3,1,'baz'::text)) v(a, b, c), +
+     generate_series(1, 2) i(i);
 (1 row)
 
 drop view agg_view1;
diff --git a/src/test/regress/expected/collate.out b/src/test/regress/expected/collate.out
index 63ed9763300aa644933cf8c09c770b6a33b98db4..4ab9566cd10be8f9faf5bed6cab94d4e3cca9336 100644
--- a/src/test/regress/expected/collate.out
+++ b/src/test/regress/expected/collate.out
@@ -194,11 +194,19 @@ CREATE VIEW collview2 AS SELECT a, b FROM collate_test1 ORDER BY b COLLATE "C";
 CREATE VIEW collview3 AS SELECT a, lower((x || x) COLLATE "POSIX") FROM collate_test10;
 SELECT table_name, view_definition FROM information_schema.views
   WHERE table_name LIKE 'collview%' ORDER BY 1;
- table_name |                                                    view_definition                                                     
-------------+------------------------------------------------------------------------------------------------------------------------
- collview1  | SELECT collate_test1.a, collate_test1.b FROM collate_test1 WHERE ((collate_test1.b COLLATE "C") >= 'bbc'::text);
- collview2  | SELECT collate_test1.a, collate_test1.b FROM collate_test1 ORDER BY (collate_test1.b COLLATE "C");
- collview3  | SELECT collate_test10.a, lower(((collate_test10.x || collate_test10.x) COLLATE "POSIX")) AS lower FROM collate_test10;
+ table_name |                               view_definition                                
+------------+------------------------------------------------------------------------------
+ collview1  |  SELECT collate_test1.a,                                                    +
+            |     collate_test1.b                                                         +
+            |    FROM collate_test1                                                       +
+            |   WHERE ((collate_test1.b COLLATE "C") >= 'bbc'::text);
+ collview2  |  SELECT collate_test1.a,                                                    +
+            |     collate_test1.b                                                         +
+            |    FROM collate_test1                                                       +
+            |   ORDER BY (collate_test1.b COLLATE "C");
+ collview3  |  SELECT collate_test10.a,                                                   +
+            |     lower(((collate_test10.x || collate_test10.x) COLLATE "POSIX")) AS lower+
+            |    FROM collate_test10;
 (3 rows)
 
 -- collation propagation in various expression types
diff --git a/src/test/regress/expected/create_view.out b/src/test/regress/expected/create_view.out
index 5e235bb98f1dffea062b01c9fb84e0a0f933ae4e..11ac795677858074c7617102d07aaa9874148240 100644
--- a/src/test/regress/expected/create_view.out
+++ b/src/test/regress/expected/create_view.out
@@ -312,7 +312,9 @@ CREATE VIEW aliased_view_4 AS
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.f1, tt1.f2, tt1.f3
+ SELECT tt1.f1, 
+    tt1.f2, 
+    tt1.f3
    FROM tt1
   WHERE (EXISTS ( SELECT 1
            FROM tx1
@@ -326,7 +328,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM tt1 a1
   WHERE (EXISTS ( SELECT 1
            FROM tx1
@@ -340,7 +344,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.f1, tt1.f2, tt1.f3
+ SELECT tt1.f1, 
+    tt1.f2, 
+    tt1.f3
    FROM tt1
   WHERE (EXISTS ( SELECT 1
            FROM tx1 a2
@@ -354,7 +360,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.y1, tt1.f2, tt1.f3
+ SELECT tt1.y1, 
+    tt1.f2, 
+    tt1.f3
    FROM temp_view_test.tt1
   WHERE (EXISTS ( SELECT 1
            FROM tt1 tt1_1
@@ -369,7 +377,9 @@ ALTER TABLE tx1 RENAME TO a1;
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.f1, tt1.f2, tt1.f3
+ SELECT tt1.f1, 
+    tt1.f2, 
+    tt1.f3
    FROM tt1
   WHERE (EXISTS ( SELECT 1
            FROM a1
@@ -383,7 +393,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM tt1 a1
   WHERE (EXISTS ( SELECT 1
            FROM a1 a1_1
@@ -397,7 +409,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.f1, tt1.f2, tt1.f3
+ SELECT tt1.f1, 
+    tt1.f2, 
+    tt1.f3
    FROM tt1
   WHERE (EXISTS ( SELECT 1
            FROM a1 a2
@@ -411,7 +425,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.y1, tt1.f2, tt1.f3
+ SELECT tt1.y1, 
+    tt1.f2, 
+    tt1.f3
    FROM temp_view_test.tt1
   WHERE (EXISTS ( SELECT 1
            FROM tt1 tt1_1
@@ -426,7 +442,9 @@ ALTER TABLE tt1 RENAME TO a2;
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a2.f1, a2.f2, a2.f3
+ SELECT a2.f1, 
+    a2.f2, 
+    a2.f3
    FROM a2
   WHERE (EXISTS ( SELECT 1
            FROM a1
@@ -440,7 +458,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM a2 a1
   WHERE (EXISTS ( SELECT 1
            FROM a1 a1_1
@@ -454,7 +474,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a2.f1, a2.f2, a2.f3
+ SELECT a2.f1, 
+    a2.f2, 
+    a2.f3
    FROM a2
   WHERE (EXISTS ( SELECT 1
            FROM a1 a2_1
@@ -468,7 +490,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.y1, tt1.f2, tt1.f3
+ SELECT tt1.y1, 
+    tt1.f2, 
+    tt1.f3
    FROM temp_view_test.tt1
   WHERE (EXISTS ( SELECT 1
            FROM a2
@@ -483,7 +507,9 @@ ALTER TABLE a1 RENAME TO tt1;
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a2.f1, a2.f2, a2.f3
+ SELECT a2.f1, 
+    a2.f2, 
+    a2.f3
    FROM a2
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -497,7 +523,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM a2 a1
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -511,7 +539,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a2.f1, a2.f2, a2.f3
+ SELECT a2.f1, 
+    a2.f2, 
+    a2.f3
    FROM a2
   WHERE (EXISTS ( SELECT 1
            FROM tt1 a2_1
@@ -525,7 +555,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.y1, tt1.f2, tt1.f3
+ SELECT tt1.y1, 
+    tt1.f2, 
+    tt1.f3
    FROM temp_view_test.tt1
   WHERE (EXISTS ( SELECT 1
            FROM a2
@@ -541,7 +573,9 @@ ALTER TABLE tx1 SET SCHEMA temp_view_test;
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tx1.f1, tx1.f2, tx1.f3
+ SELECT tx1.f1, 
+    tx1.f2, 
+    tx1.f3
    FROM temp_view_test.tx1
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -555,7 +589,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM temp_view_test.tx1 a1
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -569,7 +605,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tx1.f1, tx1.f2, tx1.f3
+ SELECT tx1.f1, 
+    tx1.f2, 
+    tx1.f3
    FROM temp_view_test.tx1
   WHERE (EXISTS ( SELECT 1
            FROM tt1 a2
@@ -583,7 +621,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tt1.y1, tt1.f2, tt1.f3
+ SELECT tt1.y1, 
+    tt1.f2, 
+    tt1.f3
    FROM temp_view_test.tt1
   WHERE (EXISTS ( SELECT 1
            FROM temp_view_test.tx1
@@ -600,7 +640,9 @@ ALTER TABLE tmp1 RENAME TO tx1;
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tx1.f1, tx1.f2, tx1.f3
+ SELECT tx1.f1, 
+    tx1.f2, 
+    tx1.f3
    FROM temp_view_test.tx1
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -614,7 +656,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT a1.f1, a1.f2, a1.f3
+ SELECT a1.f1, 
+    a1.f2, 
+    a1.f3
    FROM temp_view_test.tx1 a1
   WHERE (EXISTS ( SELECT 1
            FROM tt1
@@ -628,7 +672,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tx1.f1, tx1.f2, tx1.f3
+ SELECT tx1.f1, 
+    tx1.f2, 
+    tx1.f3
    FROM temp_view_test.tx1
   WHERE (EXISTS ( SELECT 1
            FROM tt1 a2
@@ -642,7 +688,9 @@ View definition:
  f2     | integer |           | plain    | 
  f3     | text    |           | extended | 
 View definition:
- SELECT tx1.y1, tx1.f2, tx1.f3
+ SELECT tx1.y1, 
+    tx1.f2, 
+    tx1.f3
    FROM tx1
   WHERE (EXISTS ( SELECT 1
            FROM temp_view_test.tx1 tx1_1
@@ -658,90 +706,132 @@ create view v2 as select * from tt2 join tt3 using (b,c) join tt4 using (b);
 create view v2a as select * from (tt2 join tt3 using (b,c) join tt4 using (b)) j;
 create view v3 as select * from tt2 join tt3 using (b,c) full join tt4 using (b);
 select pg_get_viewdef('v1', true);
-           pg_get_viewdef            
--------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax+
-    FROM tt2                        +
+      pg_get_viewdef       
+---------------------------
+  SELECT tt2.b,           +
+     tt3.c,               +
+     tt2.a,               +
+     tt3.ax               +
+    FROM tt2              +
     JOIN tt3 USING (b, c);
 (1 row)
 
 select pg_get_viewdef('v1a', true);
         pg_get_viewdef        
 ------------------------------
-  SELECT j.b, j.c, j.a, j.ax +
+  SELECT j.b,                +
+     j.c,                    +
+     j.a,                    +
+     j.ax                    +
     FROM (tt2                +
     JOIN tt3 USING (b, c)) j;
 (1 row)
 
 select pg_get_viewdef('v2', true);
-                   pg_get_viewdef                   
-----------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                       +
-    JOIN tt3 USING (b, c)                          +
+      pg_get_viewdef      
+--------------------------
+  SELECT tt2.b,          +
+     tt3.c,              +
+     tt2.a,              +
+     tt3.ax,             +
+     tt4.ay,             +
+     tt4.q               +
+    FROM tt2             +
+    JOIN tt3 USING (b, c)+
     JOIN tt4 USING (b);
 (1 row)
 
 select pg_get_viewdef('v2a', true);
-             pg_get_viewdef             
-----------------------------------------
-  SELECT j.b, j.c, j.a, j.ax, j.ay, j.q+
-    FROM (tt2                          +
-    JOIN tt3 USING (b, c)              +
+      pg_get_viewdef       
+---------------------------
+  SELECT j.b,             +
+     j.c,                 +
+     j.a,                 +
+     j.ax,                +
+     j.ay,                +
+     j.q                  +
+    FROM (tt2             +
+    JOIN tt3 USING (b, c) +
     JOIN tt4 USING (b)) j;
 (1 row)
 
 select pg_get_viewdef('v3', true);
-                 pg_get_viewdef                 
-------------------------------------------------
-  SELECT b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                   +
-    JOIN tt3 USING (b, c)                      +
+       pg_get_viewdef        
+-----------------------------
+  SELECT b,                 +
+     tt3.c,                 +
+     tt2.a,                 +
+     tt3.ax,                +
+     tt4.ay,                +
+     tt4.q                  +
+    FROM tt2                +
+    JOIN tt3 USING (b, c)   +
     FULL JOIN tt4 USING (b);
 (1 row)
 
 alter table tt2 add column d int;
 alter table tt2 add column e int;
 select pg_get_viewdef('v1', true);
-           pg_get_viewdef            
--------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax+
-    FROM tt2                        +
+      pg_get_viewdef       
+---------------------------
+  SELECT tt2.b,           +
+     tt3.c,               +
+     tt2.a,               +
+     tt3.ax               +
+    FROM tt2              +
     JOIN tt3 USING (b, c);
 (1 row)
 
 select pg_get_viewdef('v1a', true);
         pg_get_viewdef        
 ------------------------------
-  SELECT j.b, j.c, j.a, j.ax +
+  SELECT j.b,                +
+     j.c,                    +
+     j.a,                    +
+     j.ax                    +
     FROM (tt2                +
     JOIN tt3 USING (b, c)) j;
 (1 row)
 
 select pg_get_viewdef('v2', true);
-                   pg_get_viewdef                   
-----------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                       +
-    JOIN tt3 USING (b, c)                          +
+      pg_get_viewdef      
+--------------------------
+  SELECT tt2.b,          +
+     tt3.c,              +
+     tt2.a,              +
+     tt3.ax,             +
+     tt4.ay,             +
+     tt4.q               +
+    FROM tt2             +
+    JOIN tt3 USING (b, c)+
     JOIN tt4 USING (b);
 (1 row)
 
 select pg_get_viewdef('v2a', true);
-             pg_get_viewdef             
-----------------------------------------
-  SELECT j.b, j.c, j.a, j.ax, j.ay, j.q+
-    FROM (tt2                          +
-    JOIN tt3 USING (b, c)              +
+      pg_get_viewdef       
+---------------------------
+  SELECT j.b,             +
+     j.c,                 +
+     j.a,                 +
+     j.ax,                +
+     j.ay,                +
+     j.q                  +
+    FROM (tt2             +
+    JOIN tt3 USING (b, c) +
     JOIN tt4 USING (b)) j;
 (1 row)
 
 select pg_get_viewdef('v3', true);
-                 pg_get_viewdef                 
-------------------------------------------------
-  SELECT b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                   +
-    JOIN tt3 USING (b, c)                      +
+       pg_get_viewdef        
+-----------------------------
+  SELECT b,                 +
+     tt3.c,                 +
+     tt2.a,                 +
+     tt3.ax,                +
+     tt4.ay,                +
+     tt4.q                  +
+    FROM tt2                +
+    JOIN tt3 USING (b, c)   +
     FULL JOIN tt4 USING (b);
 (1 row)
 
@@ -749,7 +839,10 @@ alter table tt3 rename c to d;
 select pg_get_viewdef('v1', true);
              pg_get_viewdef              
 -----------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax    +
+  SELECT tt2.b,                         +
+     tt3.c,                             +
+     tt2.a,                             +
+     tt3.ax                             +
     FROM tt2                            +
     JOIN tt3 tt3(ax, b, c) USING (b, c);
 (1 row)
@@ -757,35 +850,53 @@ select pg_get_viewdef('v1', true);
 select pg_get_viewdef('v1a', true);
                pg_get_viewdef               
 --------------------------------------------
-  SELECT j.b, j.c, j.a, j.ax               +
+  SELECT j.b,                              +
+     j.c,                                  +
+     j.a,                                  +
+     j.ax                                  +
     FROM (tt2                              +
     JOIN tt3 tt3(ax, b, c) USING (b, c)) j;
 (1 row)
 
 select pg_get_viewdef('v2', true);
-                   pg_get_viewdef                   
-----------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                       +
-    JOIN tt3 tt3(ax, b, c) USING (b, c)            +
+             pg_get_viewdef             
+----------------------------------------
+  SELECT tt2.b,                        +
+     tt3.c,                            +
+     tt2.a,                            +
+     tt3.ax,                           +
+     tt4.ay,                           +
+     tt4.q                             +
+    FROM tt2                           +
+    JOIN tt3 tt3(ax, b, c) USING (b, c)+
     JOIN tt4 USING (b);
 (1 row)
 
 select pg_get_viewdef('v2a', true);
              pg_get_viewdef             
 ----------------------------------------
-  SELECT j.b, j.c, j.a, j.ax, j.ay, j.q+
+  SELECT j.b,                          +
+     j.c,                              +
+     j.a,                              +
+     j.ax,                             +
+     j.ay,                             +
+     j.q                               +
     FROM (tt2                          +
     JOIN tt3 tt3(ax, b, c) USING (b, c)+
     JOIN tt4 USING (b)) j;
 (1 row)
 
 select pg_get_viewdef('v3', true);
-                 pg_get_viewdef                 
-------------------------------------------------
-  SELECT b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                   +
-    JOIN tt3 tt3(ax, b, c) USING (b, c)        +
+             pg_get_viewdef             
+----------------------------------------
+  SELECT b,                            +
+     tt3.c,                            +
+     tt2.a,                            +
+     tt3.ax,                           +
+     tt4.ay,                           +
+     tt4.q                             +
+    FROM tt2                           +
+    JOIN tt3 tt3(ax, b, c) USING (b, c)+
     FULL JOIN tt4 USING (b);
 (1 row)
 
@@ -794,7 +905,10 @@ alter table tt3 add column e int;
 select pg_get_viewdef('v1', true);
                  pg_get_viewdef                  
 -------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax            +
+  SELECT tt2.b,                                 +
+     tt3.c,                                     +
+     tt2.a,                                     +
+     tt3.ax                                     +
     FROM tt2                                    +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c);
 (1 row)
@@ -802,24 +916,37 @@ select pg_get_viewdef('v1', true);
 select pg_get_viewdef('v1a', true);
                                  pg_get_viewdef                                  
 ---------------------------------------------------------------------------------
-  SELECT j.b, j.c, j.a, j.ax                                                    +
+  SELECT j.b,                                                                   +
+     j.c,                                                                       +
+     j.a,                                                                       +
+     j.ax                                                                       +
     FROM (tt2                                                                   +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)) j(b, c, a, d, e, ax, c_1, e_1);
 (1 row)
 
 select pg_get_viewdef('v2', true);
-                   pg_get_viewdef                   
-----------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                       +
-    JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)    +
+                 pg_get_viewdef                 
+------------------------------------------------
+  SELECT tt2.b,                                +
+     tt3.c,                                    +
+     tt2.a,                                    +
+     tt3.ax,                                   +
+     tt4.ay,                                   +
+     tt4.q                                     +
+    FROM tt2                                   +
+    JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)+
     JOIN tt4 USING (b);
 (1 row)
 
 select pg_get_viewdef('v2a', true);
                         pg_get_viewdef                         
 ---------------------------------------------------------------
-  SELECT j.b, j.c, j.a, j.ax, j.ay, j.q                       +
+  SELECT j.b,                                                 +
+     j.c,                                                     +
+     j.a,                                                     +
+     j.ax,                                                    +
+     j.ay,                                                    +
+     j.q                                                      +
     FROM (tt2                                                 +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)               +
     JOIN tt4 USING (b)) j(b, c, a, d, e, ax, c_1, e_1, ay, q);
@@ -828,7 +955,12 @@ select pg_get_viewdef('v2a', true);
 select pg_get_viewdef('v3', true);
                  pg_get_viewdef                 
 ------------------------------------------------
-  SELECT b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
+  SELECT b,                                    +
+     tt3.c,                                    +
+     tt2.a,                                    +
+     tt3.ax,                                   +
+     tt4.ay,                                   +
+     tt4.q                                     +
     FROM tt2                                   +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)+
     FULL JOIN tt4 USING (b);
@@ -838,7 +970,10 @@ alter table tt2 drop column d;
 select pg_get_viewdef('v1', true);
                  pg_get_viewdef                  
 -------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax            +
+  SELECT tt2.b,                                 +
+     tt3.c,                                     +
+     tt2.a,                                     +
+     tt3.ax                                     +
     FROM tt2                                    +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c);
 (1 row)
@@ -846,24 +981,37 @@ select pg_get_viewdef('v1', true);
 select pg_get_viewdef('v1a', true);
                                 pg_get_viewdef                                
 ------------------------------------------------------------------------------
-  SELECT j.b, j.c, j.a, j.ax                                                 +
+  SELECT j.b,                                                                +
+     j.c,                                                                    +
+     j.a,                                                                    +
+     j.ax                                                                    +
     FROM (tt2                                                                +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)) j(b, c, a, e, ax, c_1, e_1);
 (1 row)
 
 select pg_get_viewdef('v2', true);
-                   pg_get_viewdef                   
-----------------------------------------------------
-  SELECT tt2.b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
-    FROM tt2                                       +
-    JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)    +
+                 pg_get_viewdef                 
+------------------------------------------------
+  SELECT tt2.b,                                +
+     tt3.c,                                    +
+     tt2.a,                                    +
+     tt3.ax,                                   +
+     tt4.ay,                                   +
+     tt4.q                                     +
+    FROM tt2                                   +
+    JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)+
     JOIN tt4 USING (b);
 (1 row)
 
 select pg_get_viewdef('v2a', true);
                        pg_get_viewdef                       
 ------------------------------------------------------------
-  SELECT j.b, j.c, j.a, j.ax, j.ay, j.q                    +
+  SELECT j.b,                                              +
+     j.c,                                                  +
+     j.a,                                                  +
+     j.ax,                                                 +
+     j.ay,                                                 +
+     j.q                                                   +
     FROM (tt2                                              +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)            +
     JOIN tt4 USING (b)) j(b, c, a, e, ax, c_1, e_1, ay, q);
@@ -872,7 +1020,12 @@ select pg_get_viewdef('v2a', true);
 select pg_get_viewdef('v3', true);
                  pg_get_viewdef                 
 ------------------------------------------------
-  SELECT b, tt3.c, tt2.a, tt3.ax, tt4.ay, tt4.q+
+  SELECT b,                                    +
+     tt3.c,                                    +
+     tt2.a,                                    +
+     tt3.ax,                                   +
+     tt4.ay,                                   +
+     tt4.q                                     +
     FROM tt2                                   +
     JOIN tt3 tt3(ax, b, c, c_1, e) USING (b, c)+
     FULL JOIN tt4 USING (b);
@@ -884,7 +1037,10 @@ create view vv1 as select * from (tt5 cross join tt6) j(aa,bb,cc,dd);
 select pg_get_viewdef('vv1', true);
             pg_get_viewdef            
 --------------------------------------
-  SELECT j.aa, j.bb, j.cc, j.dd      +
+  SELECT j.aa,                       +
+     j.bb,                           +
+     j.cc,                           +
+     j.dd                            +
     FROM (tt5                        +
    CROSS JOIN tt6) j(aa, bb, cc, dd);
 (1 row)
@@ -893,7 +1049,10 @@ alter table tt5 add column c int;
 select pg_get_viewdef('vv1', true);
              pg_get_viewdef              
 -----------------------------------------
-  SELECT j.aa, j.bb, j.cc, j.dd         +
+  SELECT j.aa,                          +
+     j.bb,                              +
+     j.cc,                              +
+     j.dd                               +
     FROM (tt5                           +
    CROSS JOIN tt6) j(aa, bb, c, cc, dd);
 (1 row)
@@ -902,7 +1061,10 @@ alter table tt5 add column cc int;
 select pg_get_viewdef('vv1', true);
                 pg_get_viewdef                 
 -----------------------------------------------
-  SELECT j.aa, j.bb, j.cc, j.dd               +
+  SELECT j.aa,                                +
+     j.bb,                                    +
+     j.cc,                                    +
+     j.dd                                     +
     FROM (tt5                                 +
    CROSS JOIN tt6) j(aa, bb, c, cc_1, cc, dd);
 (1 row)
@@ -911,7 +1073,10 @@ alter table tt5 drop column c;
 select pg_get_viewdef('vv1', true);
                pg_get_viewdef               
 --------------------------------------------
-  SELECT j.aa, j.bb, j.cc, j.dd            +
+  SELECT j.aa,                             +
+     j.bb,                                 +
+     j.cc,                                 +
+     j.dd                                  +
     FROM (tt5                              +
    CROSS JOIN tt6) j(aa, bb, cc_1, cc, dd);
 (1 row)
@@ -925,14 +1090,23 @@ select * from (values(1,2,3,4,5)) v(a,b,c,d,e)
 union all
 select * from tt7 full join tt8 using (x), tt8 tt8x;
 select pg_get_viewdef('vv2', true);
-                               pg_get_viewdef                               
-----------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.d, v.e                                   +
-            FROM ( VALUES (1,2,3,4,5)) v(a, b, c, d, e)                    +
- UNION ALL                                                                 +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, tt8x.x_1 AS d, tt8x.z AS e+
-            FROM tt7                                                       +
-       FULL JOIN tt8 USING (x), tt8 tt8x(x_1, z);
+                     pg_get_viewdef                     
+--------------------------------------------------------
+          SELECT v.a,                                  +
+             v.b,                                      +
+             v.c,                                      +
+             v.d,                                      +
+             v.e                                       +
+            FROM ( VALUES (1,2,3,4,5)) v(a, b, c, d, e)+
+ UNION ALL                                             +
+          SELECT x AS a,                               +
+             tt7.y AS b,                               +
+             tt8.z AS c,                               +
+             tt8x.x_1 AS d,                            +
+             tt8x.z AS e                               +
+            FROM tt7                                   +
+       FULL JOIN tt8 USING (x),                        +
+        tt8 tt8x(x_1, z);
 (1 row)
 
 create view vv3 as
@@ -942,16 +1116,25 @@ select * from
   tt7 full join tt8 using (x),
   tt7 tt7x full join tt8 tt8x using (x);
 select pg_get_viewdef('vv3', true);
-                             pg_get_viewdef                              
--------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.x, v.e, v.f                           +
-            FROM ( VALUES (1,2,3,4,5,6)) v(a, b, c, x, e, f)            +
- UNION ALL                                                              +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, x_1 AS x, tt7x.y AS e, +
-             tt8x.z AS f                                                +
-            FROM tt7                                                    +
-       FULL JOIN tt8 USING (x),                                         +
-     tt7 tt7x(x_1, y)                                                   +
+                       pg_get_viewdef                        
+-------------------------------------------------------------
+          SELECT v.a,                                       +
+             v.b,                                           +
+             v.c,                                           +
+             v.x,                                           +
+             v.e,                                           +
+             v.f                                            +
+            FROM ( VALUES (1,2,3,4,5,6)) v(a, b, c, x, e, f)+
+ UNION ALL                                                  +
+          SELECT x AS a,                                    +
+             tt7.y AS b,                                    +
+             tt8.z AS c,                                    +
+             x_1 AS x,                                      +
+             tt7x.y AS e,                                   +
+             tt8x.z AS f                                    +
+            FROM tt7                                        +
+       FULL JOIN tt8 USING (x),                             +
+     tt7 tt7x(x_1, y)                                       +
     FULL JOIN tt8 tt8x(x_1, z) USING (x_1);
 (1 row)
 
@@ -962,17 +1145,28 @@ select * from
   tt7 full join tt8 using (x),
   tt7 tt7x full join tt8 tt8x using (x) full join tt8 tt8y using (x);
 select pg_get_viewdef('vv4', true);
-                             pg_get_viewdef                              
--------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.x, v.e, v.f, v.g                      +
-            FROM ( VALUES (1,2,3,4,5,6,7)) v(a, b, c, x, e, f, g)       +
- UNION ALL                                                              +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, x_1 AS x, tt7x.y AS e, +
-             tt8x.z AS f, tt8y.z AS g                                   +
-            FROM tt7                                                    +
-       FULL JOIN tt8 USING (x),                                         +
-     tt7 tt7x(x_1, y)                                                   +
-    FULL JOIN tt8 tt8x(x_1, z) USING (x_1)                              +
+                          pg_get_viewdef                          
+------------------------------------------------------------------
+          SELECT v.a,                                            +
+             v.b,                                                +
+             v.c,                                                +
+             v.x,                                                +
+             v.e,                                                +
+             v.f,                                                +
+             v.g                                                 +
+            FROM ( VALUES (1,2,3,4,5,6,7)) v(a, b, c, x, e, f, g)+
+ UNION ALL                                                       +
+          SELECT x AS a,                                         +
+             tt7.y AS b,                                         +
+             tt8.z AS c,                                         +
+             x_1 AS x,                                           +
+             tt7x.y AS e,                                        +
+             tt8x.z AS f,                                        +
+             tt8y.z AS g                                         +
+            FROM tt7                                             +
+       FULL JOIN tt8 USING (x),                                  +
+     tt7 tt7x(x_1, y)                                            +
+    FULL JOIN tt8 tt8x(x_1, z) USING (x_1)                       +
     FULL JOIN tt8 tt8y(x_1, z) USING (x_1);
 (1 row)
 
@@ -981,42 +1175,71 @@ alter table tt7 add column z int;
 alter table tt7 drop column zz;
 alter table tt8 add column z2 int;
 select pg_get_viewdef('vv2', true);
-                               pg_get_viewdef                               
-----------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.d, v.e                                   +
-            FROM ( VALUES (1,2,3,4,5)) v(a, b, c, d, e)                    +
- UNION ALL                                                                 +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, tt8x.x_1 AS d, tt8x.z AS e+
-            FROM tt7                                                       +
-       FULL JOIN tt8 USING (x), tt8 tt8x(x_1, z, z2);
+                     pg_get_viewdef                     
+--------------------------------------------------------
+          SELECT v.a,                                  +
+             v.b,                                      +
+             v.c,                                      +
+             v.d,                                      +
+             v.e                                       +
+            FROM ( VALUES (1,2,3,4,5)) v(a, b, c, d, e)+
+ UNION ALL                                             +
+          SELECT x AS a,                               +
+             tt7.y AS b,                               +
+             tt8.z AS c,                               +
+             tt8x.x_1 AS d,                            +
+             tt8x.z AS e                               +
+            FROM tt7                                   +
+       FULL JOIN tt8 USING (x),                        +
+        tt8 tt8x(x_1, z, z2);
 (1 row)
 
 select pg_get_viewdef('vv3', true);
-                             pg_get_viewdef                              
--------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.x, v.e, v.f                           +
-            FROM ( VALUES (1,2,3,4,5,6)) v(a, b, c, x, e, f)            +
- UNION ALL                                                              +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, x_1 AS x, tt7x.y AS e, +
-             tt8x.z AS f                                                +
-            FROM tt7                                                    +
-       FULL JOIN tt8 USING (x),                                         +
-     tt7 tt7x(x_1, y, z)                                                +
+                       pg_get_viewdef                        
+-------------------------------------------------------------
+          SELECT v.a,                                       +
+             v.b,                                           +
+             v.c,                                           +
+             v.x,                                           +
+             v.e,                                           +
+             v.f                                            +
+            FROM ( VALUES (1,2,3,4,5,6)) v(a, b, c, x, e, f)+
+ UNION ALL                                                  +
+          SELECT x AS a,                                    +
+             tt7.y AS b,                                    +
+             tt8.z AS c,                                    +
+             x_1 AS x,                                      +
+             tt7x.y AS e,                                   +
+             tt8x.z AS f                                    +
+            FROM tt7                                        +
+       FULL JOIN tt8 USING (x),                             +
+     tt7 tt7x(x_1, y, z)                                    +
     FULL JOIN tt8 tt8x(x_1, z, z2) USING (x_1);
 (1 row)
 
 select pg_get_viewdef('vv4', true);
-                             pg_get_viewdef                              
--------------------------------------------------------------------------
-          SELECT v.a, v.b, v.c, v.x, v.e, v.f, v.g                      +
-            FROM ( VALUES (1,2,3,4,5,6,7)) v(a, b, c, x, e, f, g)       +
- UNION ALL                                                              +
-          SELECT x AS a, tt7.y AS b, tt8.z AS c, x_1 AS x, tt7x.y AS e, +
-             tt8x.z AS f, tt8y.z AS g                                   +
-            FROM tt7                                                    +
-       FULL JOIN tt8 USING (x),                                         +
-     tt7 tt7x(x_1, y, z)                                                +
-    FULL JOIN tt8 tt8x(x_1, z, z2) USING (x_1)                          +
+                          pg_get_viewdef                          
+------------------------------------------------------------------
+          SELECT v.a,                                            +
+             v.b,                                                +
+             v.c,                                                +
+             v.x,                                                +
+             v.e,                                                +
+             v.f,                                                +
+             v.g                                                 +
+            FROM ( VALUES (1,2,3,4,5,6,7)) v(a, b, c, x, e, f, g)+
+ UNION ALL                                                       +
+          SELECT x AS a,                                         +
+             tt7.y AS b,                                         +
+             tt8.z AS c,                                         +
+             x_1 AS x,                                           +
+             tt7x.y AS e,                                        +
+             tt8x.z AS f,                                        +
+             tt8y.z AS g                                         +
+            FROM tt7                                             +
+       FULL JOIN tt8 USING (x),                                  +
+     tt7 tt7x(x_1, y, z)                                         +
+    FULL JOIN tt8 tt8x(x_1, z, z2) USING (x_1)                   +
     FULL JOIN tt8 tt8y(x_1, z, z2) USING (x_1);
 (1 row)
 
diff --git a/src/test/regress/expected/polymorphism.out b/src/test/regress/expected/polymorphism.out
index a65e3b998f9a5d627bbffbf7a6231ccada4bf6de..b967f7c6f8637f3bcf467b8ac0c080bab3a6d289 100644
--- a/src/test/regress/expected/polymorphism.out
+++ b/src/test/regress/expected/polymorphism.out
@@ -1381,7 +1381,8 @@ select * from dfview;
  c3     | bigint |           | plain   | 
  c4     | bigint |           | plain   | 
 View definition:
- SELECT int8_tbl.q1, int8_tbl.q2, 
+ SELECT int8_tbl.q1, 
+    int8_tbl.q2, 
     dfunc(int8_tbl.q1, int8_tbl.q2, flag := int8_tbl.q1 > int8_tbl.q2) AS c3, 
     dfunc(int8_tbl.q1, flag := int8_tbl.q1 < int8_tbl.q2, b := int8_tbl.q2) AS c4
    FROM int8_tbl;
diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index a235571b3dff00aa0732e62d6caac04a5e28bb71..711ae53a617ac924fa4ed01ccc9ed49857e81f98 100644
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -1277,103 +1277,953 @@ drop table cchild;
 -- Check that ruleutils are working
 --
 SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schema' ORDER BY viewname;
-            viewname             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             definition                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
----------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- iexit                           | SELECT ih.name, ih.thepath, interpt_pp(ih.thepath, r.thepath) AS exit FROM ihighway ih, ramp r WHERE (ih.thepath ## r.thepath);
- pg_available_extension_versions | SELECT e.name, e.version, (x.extname IS NOT NULL) AS installed, e.superuser, e.relocatable, e.schema, e.requires, e.comment FROM (pg_available_extension_versions() e(name, version, superuser, 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_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_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_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 = 'r'::"char") AND (i.relkind = '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 FROM pg_lock_status() l(locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath);
- pg_prepared_statements          | SELECT p.name, p.statement, p.prepare_time, p.parameter_types, p.from_sql FROM pg_prepared_statement() p(name, statement, prepare_time, parameter_types, from_sql);
- 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_roles                        | SELECT pg_authid.rolname, pg_authid.rolsuper, pg_authid.rolinherit, pg_authid.rolcreaterole, pg_authid.rolcreatedb, pg_authid.rolcatupdate, pg_authid.rolcanlogin, pg_authid.rolreplication, pg_authid.rolconnlimit, '********'::text AS rolpassword, pg_authid.rolvaliduntil, 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 = 'r'::"char") THEN 'table'::text WHEN (rel.relkind = 'v'::"char") THEN '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 WHEN (pro.proisagg = true) THEN 'aggregate'::text WHEN (pro.proisagg = false) THEN 'function'::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, 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_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 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);
- 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.rolcatupdate AS usecatupd, pg_authid.rolreplication AS userepl, pg_authid.rolpassword AS passwd, (pg_authid.rolvaliduntil)::abstime 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_stat_activity                | SELECT s.datid, d.datname, s.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.waiting, s.state, s.query FROM pg_database d, pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port), pg_authid u WHERE ((s.datid = d.oid) AND (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"]));
- 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_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"])) GROUP BY c.oid, n.nspname, c.relname;
- 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, pg_stat_get_db_numbackends(d.oid) 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_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_stat_reset_time(d.oid) AS stats_reset 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_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, w.state, w.sent_location, w.write_location, w.flush_location, w.replay_location, w.sync_priority, w.sync_state FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port), pg_authid u, pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state) WHERE ((s.usesysid = u.oid) AND (s.pid = w.pid));
- 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.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.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_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"])) 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"]));
- 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.oid) - pg_stat_get_blocks_hit(x.oid)) AS tidx_blks_read, pg_stat_get_blocks_hit(x.oid) 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_class x ON ((t.reltoastidxid = x.oid))) LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"])) GROUP BY c.oid, n.nspname, c.relname, t.oid, x.oid;
- 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));
- 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 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 = 'r'::"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.usecatupd, pg_shadow.userepl, '********'::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 (pg_has_role(s.srvowner, 'USAGE'::text) OR has_server_privilege(s.oid, 'USAGE'::text)) THEN u.umoptions ELSE NULL::text[] END AS umoptions FROM ((pg_user_mapping u LEFT JOIN pg_authid a ON ((a.oid = u.umuser))) JOIN pg_foreign_server s ON ((u.umserver = s.oid)));
- 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);
- toyemp                          | SELECT emp.name, emp.age, emp.location, (12 * emp.salary) AS annualsal FROM emp;
+            viewname             |                                                                                                   definition                                                                                                    
+---------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ iexit                           |  SELECT ih.name,                                                                                                                                                                                               +
+                                 |     ih.thepath,                                                                                                                                                                                                +
+                                 |     interpt_pp(ih.thepath, r.thepath) AS exit                                                                                                                                                                  +
+                                 |    FROM ihighway ih,                                                                                                                                                                                           +
+                                 |     ramp r                                                                                                                                                                                                     +
+                                 |   WHERE (ih.thepath ## r.thepath);
+ pg_available_extension_versions |  SELECT e.name,                                                                                                                                                                                                +
+                                 |     e.version,                                                                                                                                                                                                 +
+                                 |     (x.extname IS NOT NULL) AS installed,                                                                                                                                                                      +
+                                 |     e.superuser,                                                                                                                                                                                               +
+                                 |     e.relocatable,                                                                                                                                                                                             +
+                                 |     e.schema,                                                                                                                                                                                                  +
+                                 |     e.requires,                                                                                                                                                                                                +
+                                 |     e.comment                                                                                                                                                                                                  +
+                                 |    FROM (pg_available_extension_versions() e(name, version, superuser, 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_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_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_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 = 'r'::"char") AND (i.relkind = '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                                                                                                                                                                                                 +
+                                 |    FROM pg_lock_status() l(locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath);
+ pg_prepared_statements          |  SELECT p.name,                                                                                                                                                                                                +
+                                 |     p.statement,                                                                                                                                                                                               +
+                                 |     p.prepare_time,                                                                                                                                                                                            +
+                                 |     p.parameter_types,                                                                                                                                                                                         +
+                                 |     p.from_sql                                                                                                                                                                                                 +
+                                 |    FROM pg_prepared_statement() p(name, statement, prepare_time, parameter_types, from_sql);
+ 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_roles                        |  SELECT pg_authid.rolname,                                                                                                                                                                                     +
+                                 |     pg_authid.rolsuper,                                                                                                                                                                                        +
+                                 |     pg_authid.rolinherit,                                                                                                                                                                                      +
+                                 |     pg_authid.rolcreaterole,                                                                                                                                                                                   +
+                                 |     pg_authid.rolcreatedb,                                                                                                                                                                                     +
+                                 |     pg_authid.rolcatupdate,                                                                                                                                                                                    +
+                                 |     pg_authid.rolcanlogin,                                                                                                                                                                                     +
+                                 |     pg_authid.rolreplication,                                                                                                                                                                                  +
+                                 |     pg_authid.rolconnlimit,                                                                                                                                                                                    +
+                                 |     '********'::text AS rolpassword,                                                                                                                                                                           +
+                                 |     pg_authid.rolvaliduntil,                                                                                                                                                                                   +
+                                 |     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 = 'r'::"char") THEN 'table'::text                                                                +
+                                 |                                                                                             WHEN (rel.relkind = 'v'::"char") THEN '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                                                                                                                           +
+                                 |                                                                                     WHEN (pro.proisagg = true) THEN 'aggregate'::text                                                                          +
+                                 |                                                                                     WHEN (pro.proisagg = false) THEN 'function'::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,                                                                                                                                                                        +
+                                 |                             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_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                                                                                                                                                                                               +
+                                 |    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);
+ 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.rolcatupdate AS usecatupd,                                                                                                                                                                       +
+                                 |     pg_authid.rolreplication AS userepl,                                                                                                                                                                       +
+                                 |     pg_authid.rolpassword AS passwd,                                                                                                                                                                           +
+                                 |     (pg_authid.rolvaliduntil)::abstime 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_stat_activity                |  SELECT s.datid,                                                                                                                                                                                               +
+                                 |     d.datname,                                                                                                                                                                                                 +
+                                 |     s.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.waiting,                                                                                                                                                                                                 +
+                                 |     s.state,                                                                                                                                                                                                   +
+                                 |     s.query                                                                                                                                                                                                    +
+                                 |    FROM pg_database d,                                                                                                                                                                                         +
+                                 |     pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port),     +
+                                 |     pg_authid u                                                                                                                                                                                                +
+                                 |   WHERE ((s.datid = d.oid) AND (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"]));
+ 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_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"]))                                                                                                                                                    +
+                                 |   GROUP BY c.oid, n.nspname, c.relname;
+ 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,                                                                                                                                                                                                 +
+                                 |     pg_stat_get_db_numbackends(d.oid) 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_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_stat_reset_time(d.oid) AS stats_reset                                                                                                                                                       +
+                                 |    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_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,                                                                                                                                                                                           +
+                                 |     w.state,                                                                                                                                                                                                   +
+                                 |     w.sent_location,                                                                                                                                                                                           +
+                                 |     w.write_location,                                                                                                                                                                                          +
+                                 |     w.flush_location,                                                                                                                                                                                          +
+                                 |     w.replay_location,                                                                                                                                                                                         +
+                                 |     w.sync_priority,                                                                                                                                                                                           +
+                                 |     w.sync_state                                                                                                                                                                                               +
+                                 |    FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, waiting, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port), +
+                                 |     pg_authid u,                                                                                                                                                                                               +
+                                 |     pg_stat_get_wal_senders() w(pid, state, sent_location, write_location, flush_location, replay_location, sync_priority, sync_state)                                                                         +
+                                 |   WHERE ((s.usesysid = u.oid) AND (s.pid = w.pid));
+ 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.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.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_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"]))                                                                                                                                                    +
+                                 |   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"]));
+ 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.oid) - pg_stat_get_blocks_hit(x.oid)) AS tidx_blks_read,                                                                                                                     +
+                                 |     pg_stat_get_blocks_hit(x.oid) 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_class x ON ((t.reltoastidxid = x.oid)))                                                                                                                                                        +
+                                 |    LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))                                                                                                                                                     +
+                                 |   WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char"]))                                                                                                                                                    +
+                                 |   GROUP BY c.oid, n.nspname, c.relname, t.oid, x.oid;
+ 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));
+ 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                                                                                                                                                                            +
+                                 |    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 = 'r'::"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.usecatupd,                                                                                                                                                                                       +
+                                 |     pg_shadow.userepl,                                                                                                                                                                                         +
+                                 |     '********'::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 (pg_has_role(s.srvowner, 'USAGE'::text) OR has_server_privilege(s.oid, 'USAGE'::text)) THEN u.umoptions                                                                                       +
+                                 |             ELSE NULL::text[]                                                                                                                                                                                  +
+                                 |         END AS umoptions                                                                                                                                                                                       +
+                                 |    FROM ((pg_user_mapping u                                                                                                                                                                                    +
+                                 |    LEFT JOIN pg_authid a ON ((a.oid = u.umuser)))                                                                                                                                                              +
+                                 |    JOIN pg_foreign_server s ON ((u.umserver = s.oid)));
+ 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);
+ toyemp                          |  SELECT emp.name,                                                                                                                                                                                              +
+                                 |     emp.age,                                                                                                                                                                                                   +
+                                 |     emp.location,                                                                                                                                                                                              +
+                                 |     (12 * emp.salary) AS annualsal                                                                                                                                                                             +
+                                 |    FROM emp;
 (60 rows)
 
 SELECT tablename, rulename, definition FROM pg_rules
 	ORDER BY tablename, rulename;
-   tablename   |    rulename     |                                                                                                                                  definition                                                                                                                                   
----------------+-----------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- pg_settings   | pg_settings_n   | CREATE RULE pg_settings_n AS ON UPDATE TO pg_settings DO INSTEAD NOTHING;
- pg_settings   | pg_settings_u   | CREATE RULE pg_settings_u AS ON UPDATE TO 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 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 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 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 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 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 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 rtest_nothn2 DO INSTEAD NOTHING;
- rtest_order1  | rtest_order_r1  | CREATE RULE rtest_order_r1 AS ON INSERT TO 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 shoelace_ok DO INSTEAD UPDATE shoelace SET sl_avail = (shoelace.sl_avail + new.ok_quant) WHERE (shoelace.sl_name = new.ok_name);
+   tablename   |    rulename     |                                                                                     definition                                                                                     
+---------------+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ pg_settings   | pg_settings_n   | CREATE RULE pg_settings_n AS                                                                                                                                                      +
+               |                 |     ON UPDATE TO pg_settings DO INSTEAD NOTHING;
+ pg_settings   | pg_settings_u   | CREATE RULE pg_settings_u AS                                                                                                                                                      +
+               |                 |     ON UPDATE TO 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 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 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 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 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 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 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 rtest_nothn2 DO INSTEAD NOTHING;
+ rtest_order1  | rtest_order_r1  | CREATE RULE rtest_order_r1 AS                                                                                                                                                     +
+               |                 |     ON INSERT TO 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 shoelace_ok DO INSTEAD  UPDATE shoelace SET sl_avail = (shoelace.sl_avail + new.ok_quant)                                                                        +
+               |                 |   WHERE (shoelace.sl_name = new.ok_name);
 (29 rows)
 
 --
@@ -1584,18 +2434,34 @@ select * from only t1_2;
 
 -- 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);
+                    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                              +
+                    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)
 
diff --git a/src/test/regress/expected/triggers.out b/src/test/regress/expected/triggers.out
index 5140575f2a101d7cf9b75a34932818c08767baa0..6a6ecf7e251805035191cd9ef04c33ad8ad124d6 100644
--- a/src/test/regress/expected/triggers.out
+++ b/src/test/regress/expected/triggers.out
@@ -1119,7 +1119,8 @@ DROP TRIGGER instead_of_delete_trig ON main_view;
  a      | integer |           | plain   | 
  b      | integer |           | plain   | 
 View definition:
- SELECT main_table.a, main_table.b
+ SELECT main_table.a, 
+    main_table.b
    FROM main_table;
 Triggers:
     after_del_stmt_trig AFTER DELETE ON main_view FOR EACH STATEMENT EXECUTE PROCEDURE view_trigger('after_view_del_stmt')
diff --git a/src/test/regress/expected/window.out b/src/test/regress/expected/window.out
index 49252c82ae35126aa574b1ebfb72db0bad50a9a6..752c7b42ff341bf895405e5f3f558dedb1986e63 100644
--- a/src/test/regress/expected/window.out
+++ b/src/test/regress/expected/window.out
@@ -950,9 +950,11 @@ SELECT * FROM v_window;
 (10 rows)
 
 SELECT pg_get_viewdef('v_window');
-                                                         pg_get_viewdef                                                          
----------------------------------------------------------------------------------------------------------------------------------
- SELECT i.i, sum(i.i) OVER (ORDER BY i.i ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS sum_rows FROM generate_series(1, 10) i(i);
+                                    pg_get_viewdef                                     
+---------------------------------------------------------------------------------------
+  SELECT i.i,                                                                         +
+     sum(i.i) OVER (ORDER BY i.i ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS sum_rows+
+    FROM generate_series(1, 10) i(i);
 (1 row)
 
 -- with UNION
diff --git a/src/test/regress/expected/with.out b/src/test/regress/expected/with.out
index 272118f7b70d01e18967e8de332f2afa66514892..c381715c5602153741b9e9370103fcb9fa25d5f7 100644
--- a/src/test/regress/expected/with.out
+++ b/src/test/regress/expected/with.out
@@ -300,25 +300,48 @@ SELECT * FROM vsubdepartment ORDER BY name;
 
 -- Check reverse listing
 SELECT pg_get_viewdef('vsubdepartment'::regclass);
-                                                                                                                                                                                    pg_get_viewdef                                                                                                                                                                                     
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- WITH RECURSIVE subdepartment AS (SELECT department.id, department.parent_department, department.name FROM department WHERE (department.name = 'A'::text) UNION ALL SELECT d.id, d.parent_department, d.name FROM department d, subdepartment sd WHERE (d.parent_department = sd.id)) SELECT subdepartment.id, subdepartment.parent_department, subdepartment.name FROM subdepartment;
+                    pg_get_viewdef                     
+-------------------------------------------------------
+  WITH RECURSIVE subdepartment AS (                   +
+                  SELECT department.id,               +
+                     department.parent_department,    +
+                     department.name                  +
+                    FROM department                   +
+                   WHERE (department.name = 'A'::text)+
+         UNION ALL                                    +
+                  SELECT d.id,                        +
+                     d.parent_department,             +
+                     d.name                           +
+                    FROM department d,                +
+                     subdepartment sd                 +
+                   WHERE (d.parent_department = sd.id)+
+         )                                            +
+  SELECT subdepartment.id,                            +
+     subdepartment.parent_department,                 +
+     subdepartment.name                               +
+    FROM subdepartment;
 (1 row)
 
 SELECT pg_get_viewdef('vsubdepartment'::regclass, true);
-                                pg_get_viewdef                                 
--------------------------------------------------------------------------------
-  WITH RECURSIVE subdepartment AS (                                           +
-                  SELECT department.id, department.parent_department,         +
-                     department.name                                          +
-                    FROM department                                           +
-                   WHERE department.name = 'A'::text                          +
-         UNION ALL                                                            +
-                  SELECT d.id, d.parent_department, d.name                    +
-                    FROM department d, subdepartment sd                       +
-                   WHERE d.parent_department = sd.id                          +
-         )                                                                    +
-  SELECT subdepartment.id, subdepartment.parent_department, subdepartment.name+
+                   pg_get_viewdef                    
+-----------------------------------------------------
+  WITH RECURSIVE subdepartment AS (                 +
+                  SELECT department.id,             +
+                     department.parent_department,  +
+                     department.name                +
+                    FROM department                 +
+                   WHERE department.name = 'A'::text+
+         UNION ALL                                  +
+                  SELECT d.id,                      +
+                     d.parent_department,           +
+                     d.name                         +
+                    FROM department d,              +
+                     subdepartment sd               +
+                   WHERE d.parent_department = sd.id+
+         )                                          +
+  SELECT subdepartment.id,                          +
+     subdepartment.parent_department,               +
+     subdepartment.name                             +
     FROM subdepartment;
 (1 row)
 
diff --git a/src/test/regress/expected/xml.out b/src/test/regress/expected/xml.out
index 4f1e3972dcb2c8acca273ab27de5d8ba2174b781..382f9df5093157f85351067fbf498bb18e2befa0 100644
--- a/src/test/regress/expected/xml.out
+++ b/src/test/regress/expected/xml.out
@@ -540,17 +540,18 @@ CREATE VIEW xmlview8 AS SELECT xmlserialize(content 'good' as char(10));
 CREATE VIEW xmlview9 AS SELECT xmlserialize(content 'good' as text);
 SELECT table_name, view_definition FROM information_schema.views
   WHERE table_name LIKE 'xmlview%' ORDER BY 1;
- table_name |                                                      view_definition                                                       
-------------+----------------------------------------------------------------------------------------------------------------------------
- xmlview1   | SELECT xmlcomment('test'::text) AS xmlcomment;
- xmlview2   | SELECT XMLCONCAT('hello'::xml, 'you'::xml) AS "xmlconcat";
- xmlview3   | SELECT XMLELEMENT(NAME element, XMLATTRIBUTES(1 AS ":one:", 'deuce' AS two), 'content&') AS "xmlelement";
- xmlview4   | SELECT XMLELEMENT(NAME employee, XMLFOREST(emp.name AS name, emp.age AS age, emp.salary AS pay)) AS "xmlelement" FROM emp;
- xmlview5   | SELECT XMLPARSE(CONTENT '<abc>x</abc>'::text STRIP WHITESPACE) AS "xmlparse";
- xmlview6   | SELECT XMLPI(NAME foo, 'bar'::text) AS "xmlpi";
- xmlview7   | SELECT XMLROOT('<foo/>'::xml, VERSION NO VALUE, STANDALONE YES) AS "xmlroot";
- xmlview8   | SELECT (XMLSERIALIZE(CONTENT 'good'::xml AS character(10)))::character(10) AS "xmlserialize";
- xmlview9   | SELECT XMLSERIALIZE(CONTENT 'good'::xml AS text) AS "xmlserialize";
+ table_name |                                                  view_definition                                                  
+------------+-------------------------------------------------------------------------------------------------------------------
+ xmlview1   |  SELECT xmlcomment('test'::text) AS xmlcomment;
+ xmlview2   |  SELECT XMLCONCAT('hello'::xml, 'you'::xml) AS "xmlconcat";
+ xmlview3   |  SELECT XMLELEMENT(NAME element, XMLATTRIBUTES(1 AS ":one:", 'deuce' AS two), 'content&') AS "xmlelement";
+ xmlview4   |  SELECT XMLELEMENT(NAME employee, XMLFOREST(emp.name AS name, emp.age AS age, emp.salary AS pay)) AS "xmlelement"+
+            |    FROM emp;
+ xmlview5   |  SELECT XMLPARSE(CONTENT '<abc>x</abc>'::text STRIP WHITESPACE) AS "xmlparse";
+ xmlview6   |  SELECT XMLPI(NAME foo, 'bar'::text) AS "xmlpi";
+ xmlview7   |  SELECT XMLROOT('<foo/>'::xml, VERSION NO VALUE, STANDALONE YES) AS "xmlroot";
+ xmlview8   |  SELECT (XMLSERIALIZE(CONTENT 'good'::xml AS character(10)))::character(10) AS "xmlserialize";
+ xmlview9   |  SELECT XMLSERIALIZE(CONTENT 'good'::xml AS text) AS "xmlserialize";
 (9 rows)
 
 -- Text XPath expressions evaluation
diff --git a/src/test/regress/expected/xml_1.out b/src/test/regress/expected/xml_1.out
index 044c5529ef23bff38fdf64b307c6c578578bed7d..a34d1f41dd664cf8627cae2ccf254373d743c336 100644
--- a/src/test/regress/expected/xml_1.out
+++ b/src/test/regress/expected/xml_1.out
@@ -463,10 +463,10 @@ DETAIL:  This functionality requires the server to be built with libxml support.
 HINT:  You need to rebuild PostgreSQL using --with-libxml.
 SELECT table_name, view_definition FROM information_schema.views
   WHERE table_name LIKE 'xmlview%' ORDER BY 1;
- table_name |                                view_definition                                
-------------+-------------------------------------------------------------------------------
- xmlview1   | SELECT xmlcomment('test'::text) AS xmlcomment;
- xmlview5   | SELECT XMLPARSE(CONTENT '<abc>x</abc>'::text STRIP WHITESPACE) AS "xmlparse";
+ table_name |                                view_definition                                 
+------------+--------------------------------------------------------------------------------
+ xmlview1   |  SELECT xmlcomment('test'::text) AS xmlcomment;
+ xmlview5   |  SELECT XMLPARSE(CONTENT '<abc>x</abc>'::text STRIP WHITESPACE) AS "xmlparse";
 (2 rows)
 
 -- Text XPath expressions evaluation