resolve failures in the 'rules' test suite
authorTomas Vondra <[email protected]>
Sun, 22 Jan 2017 16:26:34 +0000 (17:26 +0100)
committerTomas Vondra <[email protected]>
Sun, 22 Jan 2017 16:26:34 +0000 (17:26 +0100)
Accept the less fancy output in ruleutils tests, and remove the
rules_2.out expected output.

src/test/regress/expected/rules.out
src/test/regress/expected/rules_2.out [deleted file]
src/test/regress/sql/rules.sql

index be2669fe5518fa0ff3764968963a1d6402576d74..1e765b0943f268e2704e5350ff8b80468e0ec88b 100644 (file)
@@ -1296,952 +1296,9 @@ drop table cchild;
 --
 -- Check that ruleutils are working
 --
-SELECT viewname, definition FROM pg_views WHERE schemaname <> 'information_schema' AND schemaname <> 'storm_catalog' 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_file_settings                |  SELECT a.sourcefile,                                                                                                                                                                                                                                                                                      +
-                                 |     a.sourceline,                                                                                                                                                                                                                                                                                          +
-                                 |     a.seqno,                                                                                                                                                                                                                                                                                               +
-                                 |     a.name,                                                                                                                                                                                                                                                                                                +
-                                 |     a.setting,                                                                                                                                                                                                                                                                                             +
-                                 |     a.applied,                                                                                                                                                                                                                                                                                             +
-                                 |     a.error                                                                                                                                                                                                                                                                                                +
-                                 |    FROM pg_show_all_file_settings() a(sourcefile, sourceline, seqno, name, setting, applied, error);
- pg_group                        |  SELECT pg_authid.rolname AS groname,                                                                                                                                                                                                                                                                      +
-                                 |     pg_authid.oid AS grosysid,                                                                                                                                                                                                                                                                             +
-                                 |     ARRAY( SELECT pg_auth_members.member                                                                                                                                                                                                                                                                   +
-                                 |            FROM pg_auth_members                                                                                                                                                                                                                                                                            +
-                                 |           WHERE (pg_auth_members.roleid = pg_authid.oid)) AS grolist                                                                                                                                                                                                                                       +
-                                 |    FROM pg_authid                                                                                                                                                                                                                                                                                          +
-                                 |   WHERE (NOT pg_authid.rolcanlogin);
- pg_indexes                      |  SELECT n.nspname AS schemaname,                                                                                                                                                                                                                                                                           +
-                                 |     c.relname AS tablename,                                                                                                                                                                                                                                                                                +
-                                 |     i.relname AS indexname,                                                                                                                                                                                                                                                                                +
-                                 |     t.spcname AS tablespace,                                                                                                                                                                                                                                                                               +
-                                 |     pg_get_indexdef(i.oid) AS indexdef                                                                                                                                                                                                                                                                     +
-                                 |    FROM ((((pg_index x                                                                                                                                                                                                                                                                                     +
-                                 |      JOIN pg_class c ON ((c.oid = x.indrelid)))                                                                                                                                                                                                                                                            +
-                                 |      JOIN pg_class i ON ((i.oid = x.indexrelid)))                                                                                                                                                                                                                                                          +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))                                                                                                                                                                                                                                               +
-                                 |      LEFT JOIN pg_tablespace t ON ((t.oid = i.reltablespace)))                                                                                                                                                                                                                                             +
-                                 |   WHERE ((c.relkind = ANY (ARRAY['r'::"char", 'm'::"char"])) 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_matviews                     |  SELECT n.nspname AS schemaname,                                                                                                                                                                                                                                                                           +
-                                 |     c.relname AS matviewname,                                                                                                                                                                                                                                                                              +
-                                 |     pg_get_userbyid(c.relowner) AS matviewowner,                                                                                                                                                                                                                                                           +
-                                 |     t.spcname AS tablespace,                                                                                                                                                                                                                                                                               +
-                                 |     c.relhasindex AS hasindexes,                                                                                                                                                                                                                                                                           +
-                                 |     c.relispopulated AS ispopulated,                                                                                                                                                                                                                                                                       +
-                                 |     pg_get_viewdef(c.oid) AS definition                                                                                                                                                                                                                                                                    +
-                                 |    FROM ((pg_class c                                                                                                                                                                                                                                                                                       +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))                                                                                                                                                                                                                                               +
-                                 |      LEFT JOIN pg_tablespace t ON ((t.oid = c.reltablespace)))                                                                                                                                                                                                                                             +
-                                 |   WHERE (c.relkind = 'm'::"char");
- pg_policies                     |  SELECT n.nspname AS schemaname,                                                                                                                                                                                                                                                                           +
-                                 |     c.relname AS tablename,                                                                                                                                                                                                                                                                                +
-                                 |     pol.polname AS policyname,                                                                                                                                                                                                                                                                             +
-                                 |         CASE                                                                                                                                                                                                                                                                                               +
-                                 |             WHEN (pol.polroles = '{0}'::oid[]) THEN (string_to_array('public'::text, ''::text))::name[]                                                                                                                                                                                                    +
-                                 |             ELSE ARRAY( SELECT pg_authid.rolname                                                                                                                                                                                                                                                           +
-                                 |                FROM pg_authid                                                                                                                                                                                                                                                                              +
-                                 |               WHERE (pg_authid.oid = ANY (pol.polroles))                                                                                                                                                                                                                                                   +
-                                 |               ORDER BY pg_authid.rolname)                                                                                                                                                                                                                                                                  +
-                                 |         END AS roles,                                                                                                                                                                                                                                                                                      +
-                                 |         CASE pol.polcmd                                                                                                                                                                                                                                                                                    +
-                                 |             WHEN 'r'::"char" THEN 'SELECT'::text                                                                                                                                                                                                                                                           +
-                                 |             WHEN 'a'::"char" THEN 'INSERT'::text                                                                                                                                                                                                                                                           +
-                                 |             WHEN 'w'::"char" THEN 'UPDATE'::text                                                                                                                                                                                                                                                           +
-                                 |             WHEN 'd'::"char" THEN 'DELETE'::text                                                                                                                                                                                                                                                           +
-                                 |             WHEN '*'::"char" THEN 'ALL'::text                                                                                                                                                                                                                                                              +
-                                 |             ELSE NULL::text                                                                                                                                                                                                                                                                                +
-                                 |         END AS cmd,                                                                                                                                                                                                                                                                                        +
-                                 |     pg_get_expr(pol.polqual, pol.polrelid) AS qual,                                                                                                                                                                                                                                                        +
-                                 |     pg_get_expr(pol.polwithcheck, pol.polrelid) AS with_check                                                                                                                                                                                                                                              +
-                                 |    FROM ((pg_policy pol                                                                                                                                                                                                                                                                                    +
-                                 |      JOIN pg_class c ON ((c.oid = pol.polrelid)))                                                                                                                                                                                                                                                          +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)));
- pg_prepared_statements          |  SELECT p.name,                                                                                                                                                                                                                                                                                            +
-                                 |     p.statement,                                                                                                                                                                                                                                                                                           +
-                                 |     p.prepare_time,                                                                                                                                                                                                                                                                                        +
-                                 |     p.parameter_types,                                                                                                                                                                                                                                                                                     +
-                                 |     p.from_sql                                                                                                                                                                                                                                                                                             +
-                                 |    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_replication_origin_status    |  SELECT pg_show_replication_origin_status.local_id,                                                                                                                                                                                                                                                        +
-                                 |     pg_show_replication_origin_status.external_id,                                                                                                                                                                                                                                                         +
-                                 |     pg_show_replication_origin_status.remote_lsn,                                                                                                                                                                                                                                                          +
-                                 |     pg_show_replication_origin_status.local_lsn                                                                                                                                                                                                                                                            +
-                                 |    FROM pg_show_replication_origin_status() pg_show_replication_origin_status(local_id, external_id, remote_lsn, local_lsn);
- pg_replication_slots            |  SELECT l.slot_name,                                                                                                                                                                                                                                                                                       +
-                                 |     l.plugin,                                                                                                                                                                                                                                                                                              +
-                                 |     l.slot_type,                                                                                                                                                                                                                                                                                           +
-                                 |     l.datoid,                                                                                                                                                                                                                                                                                              +
-                                 |     d.datname AS database,                                                                                                                                                                                                                                                                                 +
-                                 |     l.active,                                                                                                                                                                                                                                                                                              +
-                                 |     l.active_pid,                                                                                                                                                                                                                                                                                          +
-                                 |     l.xmin,                                                                                                                                                                                                                                                                                                +
-                                 |     l.catalog_xmin,                                                                                                                                                                                                                                                                                        +
-                                 |     l.restart_lsn                                                                                                                                                                                                                                                                                          +
-                                 |    FROM (pg_get_replication_slots() l(slot_name, plugin, slot_type, datoid, active, active_pid, xmin, catalog_xmin, restart_lsn)                                                                                                                                                                           +
-                                 |      LEFT JOIN pg_database d ON ((l.datoid = d.oid)));
- pg_roles                        |  SELECT pg_authid.rolname,                                                                                                                                                                                                                                                                                 +
-                                 |     pg_authid.rolsuper,                                                                                                                                                                                                                                                                                    +
-                                 |     pg_authid.rolinherit,                                                                                                                                                                                                                                                                                  +
-                                 |     pg_authid.rolcreaterole,                                                                                                                                                                                                                                                                               +
-                                 |     pg_authid.rolcreatedb,                                                                                                                                                                                                                                                                                 +
-                                 |     pg_authid.rolcanlogin,                                                                                                                                                                                                                                                                                 +
-                                 |     pg_authid.rolreplication,                                                                                                                                                                                                                                                                              +
-                                 |     pg_authid.rolconnlimit,                                                                                                                                                                                                                                                                                +
-                                 |     '********'::text AS rolpassword,                                                                                                                                                                                                                                                                       +
-                                 |     pg_authid.rolvaliduntil,                                                                                                                                                                                                                                                                               +
-                                 |     pg_authid.rolbypassrls,                                                                                                                                                                                                                                                                                +
-                                 |     s.setconfig AS rolconfig,                                                                                                                                                                                                                                                                              +
-                                 |     pg_authid.oid                                                                                                                                                                                                                                                                                          +
-                                 |    FROM (pg_authid                                                                                                                                                                                                                                                                                         +
-                                 |      LEFT JOIN pg_db_role_setting s ON (((pg_authid.oid = s.setrole) AND (s.setdatabase = (0)::oid))));
- pg_rules                        |  SELECT n.nspname AS schemaname,                                                                                                                                                                                                                                                                           +
-                                 |     c.relname AS tablename,                                                                                                                                                                                                                                                                                +
-                                 |     r.rulename,                                                                                                                                                                                                                                                                                            +
-                                 |     pg_get_ruledef(r.oid) AS definition                                                                                                                                                                                                                                                                    +
-                                 |    FROM ((pg_rewrite r                                                                                                                                                                                                                                                                                     +
-                                 |      JOIN pg_class c ON ((c.oid = r.ev_class)))                                                                                                                                                                                                                                                            +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))                                                                                                                                                                                                                                               +
-                                 |   WHERE (r.rulename <> '_RETURN'::name);
- pg_seclabels                    |  SELECT l.objoid,                                                                                                                                                                                                                                                                                          +
-                                 |     l.classoid,                                                                                                                                                                                                                                                                                            +
-                                 |     l.objsubid,                                                                                                                                                                                                                                                                                            +
-                                 |         CASE                                                                                                                                                                                                                                                                                               +
-                                 |             WHEN (rel.relkind = 'r'::"char") THEN 'table'::text                                                                                                                                                                                                                                            +
-                                 |             WHEN (rel.relkind = 'v'::"char") THEN 'view'::text                                                                                                                                                                                                                                             +
-                                 |             WHEN (rel.relkind = 'm'::"char") THEN 'materialized view'::text                                                                                                                                                                                                                                +
-                                 |             WHEN (rel.relkind = 'S'::"char") THEN 'sequence'::text                                                                                                                                                                                                                                         +
-                                 |             WHEN (rel.relkind = 'f'::"char") THEN 'foreign table'::text                                                                                                                                                                                                                                    +
-                                 |             ELSE NULL::text                                                                                                                                                                                                                                                                                +
-                                 |         END AS objtype,                                                                                                                                                                                                                                                                                    +
-                                 |     rel.relnamespace AS objnamespace,                                                                                                                                                                                                                                                                      +
-                                 |         CASE                                                                                                                                                                                                                                                                                               +
-                                 |             WHEN pg_table_is_visible(rel.oid) THEN quote_ident((rel.relname)::text)                                                                                                                                                                                                                        +
-                                 |             ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((rel.relname)::text))                                                                                                                                                                                                     +
-                                 |         END AS objname,                                                                                                                                                                                                                                                                                    +
-                                 |     l.provider,                                                                                                                                                                                                                                                                                            +
-                                 |     l.label                                                                                                                                                                                                                                                                                                +
-                                 |    FROM ((pg_seclabel l                                                                                                                                                                                                                                                                                    +
-                                 |      JOIN pg_class rel ON (((l.classoid = rel.tableoid) AND (l.objoid = rel.oid))))                                                                                                                                                                                                                        +
-                                 |      JOIN pg_namespace nsp ON ((rel.relnamespace = nsp.oid)))                                                                                                                                                                                                                                              +
-                                 |   WHERE (l.objsubid = 0)                                                                                                                                                                                                                                                                                   +
-                                 | UNION ALL                                                                                                                                                                                                                                                                                                  +
-                                 |  SELECT l.objoid,                                                                                                                                                                                                                                                                                          +
-                                 |     l.classoid,                                                                                                                                                                                                                                                                                            +
-                                 |     l.objsubid,                                                                                                                                                                                                                                                                                            +
-                                 |     'column'::text AS objtype,                                                                                                                                                                                                                                                                             +
-                                 |     rel.relnamespace AS objnamespace,                                                                                                                                                                                                                                                                      +
-                                 |     ((                                                                                                                                                                                                                                                                                                     +
-                                 |         CASE                                                                                                                                                                                                                                                                                               +
-                                 |             WHEN pg_table_is_visible(rel.oid) THEN quote_ident((rel.relname)::text)                                                                                                                                                                                                                        +
-                                 |             ELSE ((quote_ident((nsp.nspname)::text) || '.'::text) || quote_ident((rel.relname)::text))                                                                                                                                                                                                     +
-                                 |         END || '.'::text) || (att.attname)::text) AS objname,                                                                                                                                                                                                                                              +
-                                 |     l.provider,                                                                                                                                                                                                                                                                                            +
-                                 |     l.label                                                                                                                                                                                                                                                                                                +
-                                 |    FROM (((pg_seclabel l                                                                                                                                                                                                                                                                                   +
-                                 |      JOIN pg_class rel ON (((l.classoid = rel.tableoid) AND (l.objoid = rel.oid))))                                                                                                                                                                                                                        +
-                                 |      JOIN pg_attribute att ON (((rel.oid = att.attrelid) AND (l.objsubid = att.attnum))))                                                                                                                                                                                                                  +
-                                 |      JOIN pg_namespace nsp ON ((rel.relnamespace = nsp.oid)))                                                                                                                                                                                                                                              +
-                                 |   WHERE (l.objsubid <> 0)                                                                                                                                                                                                                                                                                  +
-                                 | UNION ALL                                                                                                                                                                                                                                                                                                  +
-                                 |  SELECT l.objoid,                                                                                                                                                                                                                                                                                          +
-                                 |     l.classoid,                                                                                                                                                                                                                                                                                            +
-                                 |     l.objsubid,                                                                                                                                                                                                                                                                                            +
-                                 |         CASE                                                                                                                                                                                                                                                                                               +
-                                 |             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,                                                                                                                                                                                                                                                                                          +
-                                 |     a.pending_restart                                                                                                                                                                                                                                                                                      +
-                                 |    FROM pg_show_all_settings() a(name, setting, unit, category, short_desc, extra_desc, context, vartype, source, min_val, max_val, enumvals, boot_val, reset_val, sourcefile, sourceline, pending_restart);
- pg_shadow                       |  SELECT pg_authid.rolname AS usename,                                                                                                                                                                                                                                                                      +
-                                 |     pg_authid.oid AS usesysid,                                                                                                                                                                                                                                                                             +
-                                 |     pg_authid.rolcreatedb AS usecreatedb,                                                                                                                                                                                                                                                                  +
-                                 |     pg_authid.rolsuper AS usesuper,                                                                                                                                                                                                                                                                        +
-                                 |     pg_authid.rolreplication AS userepl,                                                                                                                                                                                                                                                                   +
-                                 |     pg_authid.rolbypassrls AS usebypassrls,                                                                                                                                                                                                                                                                +
-                                 |     pg_authid.rolpassword AS passwd,                                                                                                                                                                                                                                                                       +
-                                 |     (pg_authid.rolvaliduntil)::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.backend_xid,                                                                                                                                                                                                                                                                                         +
-                                 |     s.backend_xmin,                                                                                                                                                                                                                                                                                        +
-                                 |     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, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn),    +
-                                 |     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", 'm'::"char"]));
- pg_stat_all_tables              |  SELECT c.oid AS relid,                                                                                                                                                                                                                                                                                    +
-                                 |     n.nspname AS schemaname,                                                                                                                                                                                                                                                                               +
-                                 |     c.relname,                                                                                                                                                                                                                                                                                             +
-                                 |     pg_stat_get_numscans(c.oid) AS seq_scan,                                                                                                                                                                                                                                                               +
-                                 |     pg_stat_get_tuples_returned(c.oid) AS seq_tup_read,                                                                                                                                                                                                                                                    +
-                                 |     (sum(pg_stat_get_numscans(i.indexrelid)))::bigint AS idx_scan,                                                                                                                                                                                                                                         +
-                                 |     ((sum(pg_stat_get_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_tuples_fetched(c.oid)) AS idx_tup_fetch,                                                                                                                                                                                        +
-                                 |     pg_stat_get_tuples_inserted(c.oid) AS n_tup_ins,                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_get_tuples_updated(c.oid) AS n_tup_upd,                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_get_tuples_deleted(c.oid) AS n_tup_del,                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_get_tuples_hot_updated(c.oid) AS n_tup_hot_upd,                                                                                                                                                                                                                                                +
-                                 |     pg_stat_get_live_tuples(c.oid) AS n_live_tup,                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_get_dead_tuples(c.oid) AS n_dead_tup,                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_get_mod_since_analyze(c.oid) AS n_mod_since_analyze,                                                                                                                                                                                                                                           +
-                                 |     pg_stat_get_last_vacuum_time(c.oid) AS last_vacuum,                                                                                                                                                                                                                                                    +
-                                 |     pg_stat_get_last_autovacuum_time(c.oid) AS last_autovacuum,                                                                                                                                                                                                                                            +
-                                 |     pg_stat_get_last_analyze_time(c.oid) AS last_analyze,                                                                                                                                                                                                                                                  +
-                                 |     pg_stat_get_last_autoanalyze_time(c.oid) AS last_autoanalyze,                                                                                                                                                                                                                                          +
-                                 |     pg_stat_get_vacuum_count(c.oid) AS vacuum_count,                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_get_autovacuum_count(c.oid) AS autovacuum_count,                                                                                                                                                                                                                                               +
-                                 |     pg_stat_get_analyze_count(c.oid) AS analyze_count,                                                                                                                                                                                                                                                     +
-                                 |     pg_stat_get_autoanalyze_count(c.oid) AS autoanalyze_count                                                                                                                                                                                                                                              +
-                                 |    FROM ((pg_class c                                                                                                                                                                                                                                                                                       +
-                                 |      LEFT JOIN pg_index i ON ((c.oid = i.indrelid)))                                                                                                                                                                                                                                                       +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace)))                                                                                                                                                                                                                                               +
-                                 |   WHERE (c.relkind = ANY (ARRAY['r'::"char", 't'::"char", 'm'::"char"]))                                                                                                                                                                                                                                   +
-                                 |   GROUP BY c.oid, n.nspname, c.relname;
- pg_stat_archiver                |  SELECT s.archived_count,                                                                                                                                                                                                                                                                                  +
-                                 |     s.last_archived_wal,                                                                                                                                                                                                                                                                                   +
-                                 |     s.last_archived_time,                                                                                                                                                                                                                                                                                  +
-                                 |     s.failed_count,                                                                                                                                                                                                                                                                                        +
-                                 |     s.last_failed_wal,                                                                                                                                                                                                                                                                                     +
-                                 |     s.last_failed_time,                                                                                                                                                                                                                                                                                    +
-                                 |     s.stats_reset                                                                                                                                                                                                                                                                                          +
-                                 |    FROM pg_stat_get_archiver() s(archived_count, last_archived_wal, last_archived_time, failed_count, last_failed_wal, last_failed_time, stats_reset);
- pg_stat_bgwriter                |  SELECT pg_stat_get_bgwriter_timed_checkpoints() AS checkpoints_timed,                                                                                                                                                                                                                                     +
-                                 |     pg_stat_get_bgwriter_requested_checkpoints() AS checkpoints_req,                                                                                                                                                                                                                                       +
-                                 |     pg_stat_get_checkpoint_write_time() AS checkpoint_write_time,                                                                                                                                                                                                                                          +
-                                 |     pg_stat_get_checkpoint_sync_time() AS checkpoint_sync_time,                                                                                                                                                                                                                                            +
-                                 |     pg_stat_get_bgwriter_buf_written_checkpoints() AS buffers_checkpoint,                                                                                                                                                                                                                                  +
-                                 |     pg_stat_get_bgwriter_buf_written_clean() AS buffers_clean,                                                                                                                                                                                                                                             +
-                                 |     pg_stat_get_bgwriter_maxwritten_clean() AS maxwritten_clean,                                                                                                                                                                                                                                           +
-                                 |     pg_stat_get_buf_written_backend() AS buffers_backend,                                                                                                                                                                                                                                                  +
-                                 |     pg_stat_get_buf_fsync_backend() AS buffers_backend_fsync,                                                                                                                                                                                                                                              +
-                                 |     pg_stat_get_buf_alloc() AS buffers_alloc,                                                                                                                                                                                                                                                              +
-                                 |     pg_stat_get_bgwriter_stat_reset_time() AS stats_reset;
- pg_stat_database                |  SELECT d.oid AS datid,                                                                                                                                                                                                                                                                                    +
-                                 |     d.datname,                                                                                                                                                                                                                                                                                             +
-                                 |     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,                                                                                                                                                                                                                                                                                       +
-                                 |     s.backend_xmin,                                                                                                                                                                                                                                                                                        +
-                                 |     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, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn),+
-                                 |     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_ssl                     |  SELECT s.pid,                                                                                                                                                                                                                                                                                             +
-                                 |     s.ssl,                                                                                                                                                                                                                                                                                                 +
-                                 |     s.sslversion AS version,                                                                                                                                                                                                                                                                               +
-                                 |     s.sslcipher AS cipher,                                                                                                                                                                                                                                                                                 +
-                                 |     s.sslbits AS bits,                                                                                                                                                                                                                                                                                     +
-                                 |     s.sslcompression AS compression,                                                                                                                                                                                                                                                                       +
-                                 |     s.sslclientdn AS clientdn                                                                                                                                                                                                                                                                              +
-                                 |    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, backend_xid, backend_xmin, ssl, sslversion, sslcipher, sslbits, sslcompression, sslclientdn);
- pg_stat_sys_indexes             |  SELECT pg_stat_all_indexes.relid,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_indexes.indexrelid,                                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_all_indexes.schemaname,                                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_all_indexes.relname,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_indexes.indexrelname,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_indexes.idx_scan,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_indexes.idx_tup_read,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_indexes.idx_tup_fetch                                                                                                                                                                                                                                                                      +
-                                 |    FROM pg_stat_all_indexes                                                                                                                                                                                                                                                                                +
-                                 |   WHERE ((pg_stat_all_indexes.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_stat_all_indexes.schemaname ~ '^pg_toast'::text));
- pg_stat_sys_tables              |  SELECT pg_stat_all_tables.relid,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.schemaname,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.relname,                                                                                                                                                                                                                                                                            +
-                                 |     pg_stat_all_tables.seq_scan,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_tables.seq_tup_read,                                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_all_tables.idx_scan,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_tables.idx_tup_fetch,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_tables.n_tup_ins,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_upd,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_del,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_hot_upd,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_tables.n_live_tup,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.n_dead_tup,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.n_mod_since_analyze,                                                                                                                                                                                                                                                                +
-                                 |     pg_stat_all_tables.last_vacuum,                                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_all_tables.last_autovacuum,                                                                                                                                                                                                                                                                    +
-                                 |     pg_stat_all_tables.last_analyze,                                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_all_tables.last_autoanalyze,                                                                                                                                                                                                                                                                   +
-                                 |     pg_stat_all_tables.vacuum_count,                                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_all_tables.autovacuum_count,                                                                                                                                                                                                                                                                   +
-                                 |     pg_stat_all_tables.analyze_count,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_tables.autoanalyze_count                                                                                                                                                                                                                                                                   +
-                                 |    FROM pg_stat_all_tables                                                                                                                                                                                                                                                                                 +
-                                 |   WHERE ((pg_stat_all_tables.schemaname = ANY (ARRAY['pg_catalog'::name, 'information_schema'::name])) OR (pg_stat_all_tables.schemaname ~ '^pg_toast'::text));
- pg_stat_user_functions          |  SELECT p.oid AS funcid,                                                                                                                                                                                                                                                                                   +
-                                 |     n.nspname AS schemaname,                                                                                                                                                                                                                                                                               +
-                                 |     p.proname AS funcname,                                                                                                                                                                                                                                                                                 +
-                                 |     pg_stat_get_function_calls(p.oid) AS calls,                                                                                                                                                                                                                                                            +
-                                 |     pg_stat_get_function_total_time(p.oid) AS total_time,                                                                                                                                                                                                                                                  +
-                                 |     pg_stat_get_function_self_time(p.oid) AS self_time                                                                                                                                                                                                                                                     +
-                                 |    FROM (pg_proc p                                                                                                                                                                                                                                                                                         +
-                                 |      LEFT JOIN pg_namespace n ON ((n.oid = p.pronamespace)))                                                                                                                                                                                                                                               +
-                                 |   WHERE ((p.prolang <> (12)::oid) AND (pg_stat_get_function_calls(p.oid) IS NOT NULL));
- pg_stat_user_indexes            |  SELECT pg_stat_all_indexes.relid,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_indexes.indexrelid,                                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_all_indexes.schemaname,                                                                                                                                                                                                                                                                        +
-                                 |     pg_stat_all_indexes.relname,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_indexes.indexrelname,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_indexes.idx_scan,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_indexes.idx_tup_read,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_indexes.idx_tup_fetch                                                                                                                                                                                                                                                                      +
-                                 |    FROM pg_stat_all_indexes                                                                                                                                                                                                                                                                                +
-                                 |   WHERE ((pg_stat_all_indexes.schemaname <> ALL (ARRAY['pg_catalog'::name, 'information_schema'::name])) AND (pg_stat_all_indexes.schemaname !~ '^pg_toast'::text));
- pg_stat_user_tables             |  SELECT pg_stat_all_tables.relid,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.schemaname,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.relname,                                                                                                                                                                                                                                                                            +
-                                 |     pg_stat_all_tables.seq_scan,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_tables.seq_tup_read,                                                                                                                                                                                                                                                                       +
-                                 |     pg_stat_all_tables.idx_scan,                                                                                                                                                                                                                                                                           +
-                                 |     pg_stat_all_tables.idx_tup_fetch,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_tables.n_tup_ins,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_upd,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_del,                                                                                                                                                                                                                                                                          +
-                                 |     pg_stat_all_tables.n_tup_hot_upd,                                                                                                                                                                                                                                                                      +
-                                 |     pg_stat_all_tables.n_live_tup,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.n_dead_tup,                                                                                                                                                                                                                                                                         +
-                                 |     pg_stat_all_tables.n_mod_since_analyze,                                                                                                                                                                                                                                                                +
-                                 |     pg_stat_all_tables.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)))                                                                                                            &