@akal/pg-conformance 0.0.0-stage → 0.0.15

package/corpus/objects.json

@@ -0,0 +1,202 @@
+[
+  {
+    "id": "obj_create_table_pk",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_books (id bigint PRIMARY KEY, title text NOT NULL);",
+    "description": "create a table with a primary key from nothing",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_serial",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_serial (id serial PRIMARY KEY, name text);",
+    "description": "serial column must round-trip with its owned sequence",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_identity",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_ident (id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, n text);",
+    "description": "identity column from nothing",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_identity_increment",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_ident2 (id bigint GENERATED ALWAYS AS IDENTITY (INCREMENT 10 START 100), n text);",
+    "description": "identity carrying non-default sequence options",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_enum_column",
+    "source_file": "objects",
+    "category": "create_type",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TYPE o_mood AS ENUM ('ok','bad'); CREATE TABLE o_t (id int PRIMARY KEY, m o_mood);",
+    "description": "enum type plus a column using it",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_composite",
+    "source_file": "objects",
+    "category": "create_type",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TYPE o_addr AS (street text, city text);",
+    "description": "composite type",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_domain",
+    "source_file": "objects",
+    "category": "create_type",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE DOMAIN o_pos AS integer CHECK (VALUE > 0);",
+    "description": "domain with a constraint",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_partitioned_range",
+    "source_file": "objects",
+    "category": "partition",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_sales (id bigint, d date NOT NULL, PRIMARY KEY (d,id)) PARTITION BY RANGE (d); CREATE TABLE o_sales_26 PARTITION OF o_sales FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');",
+    "description": "partitioned parent plus an attached partition",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_partitioned_list",
+    "source_file": "objects",
+    "category": "partition",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_reg (id bigint, r text NOT NULL, PRIMARY KEY (r,id)) PARTITION BY LIST (r); CREATE TABLE o_reg_emea PARTITION OF o_reg FOR VALUES IN ('emea');",
+    "description": "list partitioning",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_partition_index",
+    "source_file": "objects",
+    "category": "partition",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_pidx (id bigint, d date NOT NULL, PRIMARY KEY (d,id)) PARTITION BY RANGE (d); CREATE TABLE o_pidx_26 PARTITION OF o_pidx FOR VALUES FROM ('2026-01-01') TO ('2027-01-01'); CREATE INDEX o_pidx_d ON o_pidx (d);",
+    "description": "index on a partitioned parent must reach its partitions",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_view",
+    "source_file": "objects",
+    "category": "create_view",
+    "table": "",
+    "before_sql": "CREATE TABLE o_vt (id int PRIMARY KEY, name text);",
+    "alter_sql": "CREATE VIEW o_v AS SELECT id, name FROM o_vt;",
+    "description": "view over an existing table",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_view_expr",
+    "source_file": "objects",
+    "category": "create_view",
+    "table": "",
+    "before_sql": "CREATE TABLE o_vt2 (id int PRIMARY KEY, a int, b int);",
+    "alter_sql": "CREATE VIEW o_v2 AS SELECT id, a + b AS total FROM o_vt2 WHERE a > 0;",
+    "description": "view with an expression and predicate",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_function",
+    "source_file": "objects",
+    "category": "create_routine",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE FUNCTION o_add(a int, b int) RETURNS int LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;",
+    "description": "plain function",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_trigger",
+    "source_file": "objects",
+    "category": "create_trigger",
+    "table": "",
+    "before_sql": "CREATE TABLE o_tt (id int PRIMARY KEY, v text);",
+    "alter_sql": "CREATE FUNCTION o_touch() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER o_tt_bu BEFORE UPDATE ON o_tt FOR EACH ROW EXECUTE FUNCTION o_touch();",
+    "description": "trigger and the function it calls, created together",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_trigger_on_partitioned",
+    "source_file": "objects",
+    "category": "create_trigger",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_pt (id bigint, d date NOT NULL, PRIMARY KEY (d,id)) PARTITION BY RANGE (d); CREATE TABLE o_pt_26 PARTITION OF o_pt FOR VALUES FROM ('2026-01-01') TO ('2027-01-01'); CREATE FUNCTION o_pt_f() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$; CREATE TRIGGER o_pt_ai AFTER INSERT ON o_pt FOR EACH ROW EXECUTE FUNCTION o_pt_f();",
+    "description": "trigger on a partitioned parent propagates; the clone is not re-declared",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_policy",
+    "source_file": "objects",
+    "category": "create_policy",
+    "table": "",
+    "before_sql": "CREATE TABLE o_sec (id int PRIMARY KEY, owner text);",
+    "alter_sql": "ALTER TABLE o_sec ENABLE ROW LEVEL SECURITY; CREATE POLICY o_sec_read ON o_sec FOR SELECT USING (true);",
+    "description": "row level security plus a policy",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_sequence",
+    "source_file": "objects",
+    "category": "create_sequence",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE SEQUENCE o_seq START 100 INCREMENT 5 MINVALUE 100 MAXVALUE 100000 CYCLE;",
+    "description": "standalone sequence with non-default options",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_create_matview",
+    "source_file": "objects",
+    "category": "create_view",
+    "table": "",
+    "before_sql": "CREATE TABLE o_mt (id int PRIMARY KEY, n int);",
+    "alter_sql": "CREATE MATERIALIZED VIEW o_mv AS SELECT id, n FROM o_mt WHERE n > 0;",
+    "description": "materialized view",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_fk_between_tables",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_parent (id bigint PRIMARY KEY); CREATE TABLE o_child (id bigint PRIMARY KEY, p bigint NOT NULL REFERENCES o_parent(id) ON DELETE CASCADE);",
+    "description": "two tables plus the foreign key between them, ordered correctly",
+    "skip_reason": null
+  },
+  {
+    "id": "obj_generated_column",
+    "source_file": "objects",
+    "category": "create_table",
+    "table": "",
+    "before_sql": "",
+    "alter_sql": "CREATE TABLE o_gen (id int PRIMARY KEY, a int, b int GENERATED ALWAYS AS (a * 2) STORED);",
+    "description": "generated stored column",
+    "skip_reason": null
+  }
+]

package/corpus/ordering.json

@@ -0,0 +1,201 @@
+[
+  {
+    "id": "a_table_is_created_before_the_table_whose_foreign_key_points_at_it",
+    "description": "a table is created before the table whose foreign key points at it",
+    "statements": [
+      "CREATE TABLE user_profile (id int REFERENCES \"user\"(id), bio text);",
+      "CREATE TABLE \"user\" (id int PRIMARY KEY);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE \"user\"",
+        "CREATE TABLE user_profile"
+      ]
+    ]
+  },
+  {
+    "id": "quoted_names_that_collide_with_keywords_are_still_ordered",
+    "description": "quoted names that collide with keywords are still ordered",
+    "statements": [
+      "CREATE TABLE \"order\" (id int REFERENCES \"table\"(id));",
+      "CREATE TABLE \"table\" (id int PRIMARY KEY);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE \"table\"",
+        "CREATE TABLE \"order\""
+      ]
+    ]
+  },
+  {
+    "id": "a_domain_is_created_before_the_column_that_uses_it",
+    "description": "a domain is created before the column that uses it",
+    "statements": [
+      "CREATE TABLE d_t (id int, v money_amt);",
+      "CREATE DOMAIN money_amt AS numeric(10,2) CHECK (VALUE >= 0);"
+    ],
+    "requires": [
+      [
+        "CREATE DOMAIN money_amt",
+        "CREATE TABLE d_t"
+      ]
+    ]
+  },
+  {
+    "id": "a_function_is_created_before_the_check_constraint_that_calls_it",
+    "description": "a function is created before the CHECK constraint that calls it",
+    "statements": [
+      "CREATE TABLE c_t (id int, code text, CONSTRAINT c_ck CHECK (is_valid(code)));",
+      "CREATE FUNCTION is_valid(t text) RETURNS boolean LANGUAGE sql IMMUTABLE AS $$ SELECT length(t) > 2 $$;"
+    ],
+    "requires": [
+      [
+        "CREATE FUNCTION is_valid",
+        "CREATE TABLE c_t"
+      ]
+    ]
+  },
+  {
+    "id": "a_function_is_created_before_the_generated_column_that_calls_it",
+    "description": "a function is created before the generated column that calls it",
+    "statements": [
+      "CREATE TABLE g_t (id int, raw text, norm text GENERATED ALWAYS AS (norm_it(raw)) STORED);",
+      "CREATE FUNCTION norm_it(t text) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT lower(t) $$;"
+    ],
+    "requires": [
+      [
+        "CREATE FUNCTION norm_it",
+        "CREATE TABLE g_t"
+      ]
+    ]
+  },
+  {
+    "id": "a_composite_type_is_created_before_the_function_that_returns_it",
+    "description": "a composite type is created before the function that returns it",
+    "statements": [
+      "CREATE FUNCTION mk_addr() RETURNS addr_t LANGUAGE sql AS $$ SELECT ROW('a','b')::addr_t $$;",
+      "CREATE TYPE addr_t AS (street text, city text);"
+    ],
+    "requires": [
+      [
+        "CREATE TYPE addr_t",
+        "CREATE FUNCTION mk_addr"
+      ]
+    ]
+  },
+  {
+    "id": "a_view_that_selects_from_a_function_waits_for_the_function_and_its_table",
+    "description": "a view that selects from a function waits for the function and its table",
+    "statements": [
+      "CREATE VIEW v_top AS SELECT * FROM top_ids();",
+      "CREATE FUNCTION top_ids() RETURNS TABLE(id int) LANGUAGE sql AS $$ SELECT id FROM base_t $$;",
+      "CREATE TABLE base_t (id int);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE base_t",
+        "CREATE FUNCTION top_ids"
+      ],
+      [
+        "CREATE FUNCTION top_ids",
+        "CREATE VIEW v_top"
+      ]
+    ]
+  },
+  {
+    "id": "a_chain_of_views_is_created_from_the_base_outwards",
+    "description": "a chain of views is created from the base outwards",
+    "statements": [
+      "CREATE VIEW v3 AS SELECT id FROM v2;",
+      "CREATE VIEW v1 AS SELECT id FROM vbase;",
+      "CREATE VIEW v2 AS SELECT id FROM v1;",
+      "CREATE TABLE vbase (id int);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE vbase",
+        "CREATE VIEW v1"
+      ],
+      [
+        "CREATE VIEW v1",
+        "CREATE VIEW v2"
+      ],
+      [
+        "CREATE VIEW v2",
+        "CREATE VIEW v3"
+      ]
+    ]
+  },
+  {
+    "id": "a_partition_is_attached_before_the_index_on_its_parent",
+    "description": "a partition is attached before the index on its parent",
+    "statements": [
+      "CREATE INDEX p_i ON ONLY p_tbl (d);",
+      "CREATE TABLE p_26 PARTITION OF p_tbl FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');",
+      "CREATE TABLE p_tbl (id int, d date) PARTITION BY RANGE (d);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE p_tbl",
+        "CREATE TABLE p_26"
+      ],
+      [
+        "CREATE TABLE p_26",
+        "CREATE INDEX p_i"
+      ]
+    ]
+  },
+  {
+    "id": "an_enum_is_created_before_the_column_defaulting_to_one_of_its_labels",
+    "description": "an enum is created before the column defaulting to one of its labels",
+    "statements": [
+      "CREATE TABLE e_t (id int, m mood_x NOT NULL DEFAULT 'ok');",
+      "CREATE TYPE mood_x AS ENUM ('sad','ok');"
+    ],
+    "requires": [
+      [
+        "CREATE TYPE mood_x",
+        "CREATE TABLE e_t"
+      ]
+    ]
+  },
+  {
+    "id": "a_three_table_foreign_key_chain_is_created_root_first",
+    "description": "a three-table foreign key chain is created root first",
+    "statements": [
+      "CREATE TABLE l3 (id int REFERENCES l2(id));",
+      "CREATE TABLE l1 (id int PRIMARY KEY);",
+      "CREATE TABLE l2 (id int PRIMARY KEY REFERENCES l1(id));"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE l1",
+        "CREATE TABLE l2"
+      ],
+      [
+        "CREATE TABLE l2",
+        "CREATE TABLE l3"
+      ]
+    ]
+  },
+  {
+    "id": "a_trigger_waits_for_its_function_and_the_table_it_fires_on",
+    "description": "a trigger waits for its function and the table it fires on",
+    "statements": [
+      "CREATE TRIGGER t_aud AFTER INSERT ON src_t FOR EACH ROW EXECUTE FUNCTION log_it();",
+      "CREATE FUNCTION log_it() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN INSERT INTO audit_t VALUES (1); RETURN NEW; END $$;",
+      "CREATE TABLE src_t (id int);",
+      "CREATE TABLE audit_t (id int);"
+    ],
+    "requires": [
+      [
+        "CREATE TABLE src_t",
+        "CREATE TRIGGER t_aud"
+      ],
+      [
+        "CREATE FUNCTION log_it",
+        "CREATE TRIGGER t_aud"
+      ]
+    ]
+  }
+]

package/fingerprint.sql

@@ -0,0 +1,245 @@
+-- Structural fingerprint of a PostgreSQL schema.
+--
+-- One query that renders everything about a set of schemas which a migration
+-- could get wrong, as sorted text. Two databases are structurally identical if
+-- and only if this returns the same string for both.
+--
+-- Why the catalog and not information_schema
+-- ------------------------------------------
+-- information_schema is a standardised view over the catalog, and the standard
+-- has no concept of most of what matters here. It cannot tell a partitioned
+-- table from an ordinary one, has nowhere to put a partition bound, and does
+-- not expose identity sequence options, generated-column storage, compression
+-- or collation. Every one of those has hidden a real bug.
+--
+-- Why bodies, not names
+-- --------------------
+-- Objects that carry a body are compared by that body. Comparing names alone
+-- reports a view whose predicate was inverted, a function whose implementation
+-- was replaced, and a trigger moved from AFTER INSERT to BEFORE UPDATE as
+-- identical — three schemas differing in the ways most likely to matter.
+--
+-- Where PostgreSQL can render an object canonically (pg_get_viewdef,
+-- pg_get_constraintdef, pg_get_functiondef, pg_get_triggerdef, pg_get_expr)
+-- that rendering is what gets compared, so both sides are produced by the same
+-- server code and formatting can never manufacture a difference.
+--
+-- Definitions are flattened to one line. Entries are joined with newlines, so a
+-- multi-line body would otherwise arrive as several unattributed entries —
+-- losing the object name and making sort order depend on the body's layout.
+--
+-- Usage
+-- -----
+-- Replace the token __SCHEMAS__ with a quoted, comma-separated schema list,
+-- e.g. 'public','app'. The language accessors do this for you and handle
+-- quoting; do not interpolate user input by hand.
+--
+-- Requires PostgreSQL 14 or newer (pg_attribute.attcompression).
+
+SELECT string_agg(line, E'\n' ORDER BY line) AS fingerprint FROM (
+
+  -- Relations. relkind distinguishes a partitioned table from an ordinary one;
+  -- relpartbound is the only place a partition's bound exists; relpersistence
+  -- carries UNLOGGED; reloptions carries fillfactor and friends.
+  SELECT format('rel %s.%s kind=%s persist=%s bound=%s opts=%s rls=%s force_rls=%s',
+                n.nspname, c.relname, c.relkind, c.relpersistence,
+                COALESCE(btrim(regexp_replace(pg_get_expr(c.relpartbound, c.oid), '\s+', ' ', 'g')), '-'),
+                COALESCE(array_to_string(c.reloptions, ','), '-'),
+                c.relrowsecurity, c.relforcerowsecurity) AS line
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND c.relkind IN ('r','p','v','m','f','S')
+
+  UNION ALL
+
+  -- Columns, read from pg_attribute so identity, generated, storage,
+  -- compression and collation are visible at all.
+  SELECT format('col %s.%s.%s type=%s notnull=%s default=%s ident=%s gen=%s store=%s compress=%s coll=%s',
+                n.nspname, c.relname, a.attname,
+                format_type(a.atttypid, a.atttypmod),
+                a.attnotnull,
+                COALESCE(btrim(regexp_replace(pg_get_expr(d.adbin, d.adrelid), '\s+', ' ', 'g')), '-'),
+                a.attidentity, a.attgenerated, a.attstorage,
+                COALESCE(a.attcompression::text, '-'),
+                COALESCE(co.collname, '-'))
+    FROM pg_attribute a
+    JOIN pg_class c ON c.oid = a.attrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+    LEFT JOIN pg_collation co ON co.oid = a.attcollation
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND a.attnum > 0 AND NOT a.attisdropped
+     AND c.relkind IN ('r','p','v','m','f')
+
+  UNION ALL
+
+  -- Sequence options. An identity column's sequence is part of the column: a
+  -- table rebuilt without INCREMENT and START silently restarts its counter.
+  SELECT format('seq %s.%s start=%s inc=%s min=%s max=%s cache=%s cycle=%s',
+                n.nspname, c.relname,
+                s.seqstart, s.seqincrement, s.seqmin, s.seqmax, s.seqcache, s.seqcycle)
+    FROM pg_sequence s
+    JOIN pg_class c ON c.oid = s.seqrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+
+  UNION ALL
+
+  -- Constraints, including whether they are validated and how they defer —
+  -- a NOT VALID check and a validated one are not the same constraint.
+  SELECT format('con %s.%s.%s %s valid=%s deferrable=%s deferred=%s',
+                n.nspname, c.relname, con.conname,
+                btrim(regexp_replace(pg_get_constraintdef(con.oid), '\s+', ' ', 'g')),
+                con.convalidated, con.condeferrable, con.condeferred)
+    FROM pg_constraint con
+    JOIN pg_class c ON c.oid = con.conrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+
+  UNION ALL
+
+  -- Indexes, per relation. An index created ON ONLY a partitioned parent never
+  -- reaches its partitions, and only a per-relation comparison shows that.
+  SELECT format('idx %s.%s %s', schemaname, indexname,
+                btrim(regexp_replace(indexdef, '\s+', ' ', 'g')))
+    FROM pg_indexes
+   WHERE schemaname IN (__SCHEMAS__)
+
+  UNION ALL
+
+  -- Views and materialised views, by body.
+  SELECT format('view %s.%s %s opts=%s',
+                n.nspname, c.relname,
+                btrim(regexp_replace(pg_get_viewdef(c.oid, true), '\s+', ' ', 'g')),
+                COALESCE(array_to_string(c.reloptions, ','), '-'))
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND c.relkind IN ('v','m')
+
+  UNION ALL
+
+  -- Routines, by body. prokind is filtered because pg_get_functiondef raises
+  -- an error on aggregate and window functions.
+  SELECT format('fn %s.%s(%s) %s',
+                n.nspname, p.proname,
+                pg_get_function_identity_arguments(p.oid),
+                btrim(regexp_replace(pg_get_functiondef(p.oid), '\s+', ' ', 'g')))
+    FROM pg_proc p
+    JOIN pg_namespace n ON n.oid = p.pronamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND p.prokind IN ('f','p')
+
+  UNION ALL
+
+  -- Triggers, by definition. tgparentid excludes the per-partition clones
+  -- PostgreSQL creates automatically, which are not independent objects.
+  SELECT format('trg %s.%s.%s %s',
+                n.nspname, c.relname, t.tgname,
+                btrim(regexp_replace(pg_get_triggerdef(t.oid), '\s+', ' ', 'g')))
+    FROM pg_trigger t
+    JOIN pg_class c ON c.oid = t.tgrelid
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND NOT t.tgisinternal
+     AND t.tgparentid = 0
+
+  UNION ALL
+
+  -- Policies. USING alone is not the policy: the command, the roles and the
+  -- WITH CHECK expression all decide who may do what.
+  SELECT format('pol %s.%s.%s cmd=%s permissive=%s roles=%s using=%s check=%s',
+                schemaname, tablename, policyname, cmd, permissive,
+                array_to_string(roles, ','),
+                COALESCE(btrim(regexp_replace(qual, '\s+', ' ', 'g')), '-'),
+                COALESCE(btrim(regexp_replace(with_check, '\s+', ' ', 'g')), '-'))
+    FROM pg_policies
+   WHERE schemaname IN (__SCHEMAS__)
+
+  UNION ALL
+
+  -- Enums, domains and composite types. Enum label order is significant:
+  -- it decides comparison and ORDER BY.
+  --
+  -- Every kind's content is carried inline, the way enum labels are, because no
+  -- other section can reach it. The col section reads relations (relkind
+  -- r/p/v/m/f) and so never sees a standalone composite's attributes, which are
+  -- on a 'c'; the con section joins conrelid, while a domain's CHECK is keyed by
+  -- contypid and has no conrelid at all. Until these were here, a composite of
+  -- (street text, city text) and one of (postcode int) fingerprinted the same,
+  -- as did domains with CHECK (VALUE > 0) and CHECK (VALUE < -999) — the same
+  -- class of silent agreement this file exists to prevent.
+  --
+  -- Only CHECK constraints are read. PostgreSQL 17 began recording a domain's
+  -- NOT NULL as a constraint row of its own, and notnull= already carries it;
+  -- taking every row would both state it twice and make one logical domain
+  -- fingerprint differently either side of that release.
+  SELECT format('typ %s.%s kind=%s labels=%s default=%s notnull=%s base=%s attrs=%s checks=%s',
+                n.nspname, t.typname, t.typtype,
+                COALESCE((SELECT string_agg(e.enumlabel, ',' ORDER BY e.enumsortorder)
+                            FROM pg_enum e WHERE e.enumtypid = t.oid), '-'),
+                COALESCE(btrim(regexp_replace(pg_get_expr(t.typdefaultbin, 0), '\s+', ' ', 'g')), '-'),
+                t.typnotnull,
+                COALESCE(CASE WHEN t.typtype = 'd'
+                              THEN format_type(t.typbasetype, t.typtypmod) END, '-'),
+                COALESCE((SELECT string_agg(
+                                   format('%s %s', a.attname,
+                                          format_type(a.atttypid, a.atttypmod)),
+                                   ',' ORDER BY a.attnum)
+                            FROM pg_attribute a
+                           WHERE a.attrelid = t.typrelid
+                             AND a.attnum > 0 AND NOT a.attisdropped), '-'),
+                COALESCE((SELECT string_agg(
+                                   format('%s %s', con.conname,
+                                          btrim(regexp_replace(
+                                            pg_get_constraintdef(con.oid), '\s+', ' ', 'g'))),
+                                   ',' ORDER BY con.conname)
+                            FROM pg_constraint con
+                           WHERE con.contypid = t.oid
+                             AND con.contype = 'c'), '-'))
+    FROM pg_type t
+    JOIN pg_namespace n ON n.oid = t.typnamespace
+   WHERE n.nspname IN (__SCHEMAS__)
+     AND t.typtype IN ('e','d','c')
+     AND NOT EXISTS (
+       SELECT 1 FROM pg_class c
+        WHERE c.oid = t.typrelid AND c.relkind <> 'c'
+     )
+
+  UNION ALL
+
+  -- Inheritance, which is not implied by anything above.
+  SELECT format('inh %s.%s <- %s.%s',
+                pn.nspname, parent.relname, cn.nspname, child.relname)
+    FROM pg_inherits i
+    JOIN pg_class child ON child.oid = i.inhrelid
+    JOIN pg_class parent ON parent.oid = i.inhparent
+    JOIN pg_namespace cn ON cn.oid = child.relnamespace
+    JOIN pg_namespace pn ON pn.oid = parent.relnamespace
+   WHERE cn.nspname IN (__SCHEMAS__)
+
+  UNION ALL
+
+  -- Comments, on anything in the schemas: tables and columns, and functions,
+  -- types, constraints, triggers, policies and the schemas themselves. Named
+  -- as PostgreSQL identifies the object, so a column by its name: keyed by
+  -- its position, the same comment on a column added last on one side read
+  -- as a difference. An extension's objects are its own.
+  SELECT format('cmt %s %s %s', i.type, i.identity,
+                btrim(regexp_replace(d.description, '\s+', ' ', 'g')))
+    FROM pg_description d
+    CROSS JOIN LATERAL pg_identify_object(d.classoid, d.objoid, d.objsubid) i
+   WHERE (i.schema IN (__SCHEMAS__)
+          -- A trigger or a policy has no schema of its own: its table's.
+          OR (SELECT n.nspname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+               WHERE c.oid = CASE d.classoid
+                               WHEN 'pg_trigger'::regclass THEN (SELECT tgrelid FROM pg_trigger WHERE oid = d.objoid)
+                               WHEN 'pg_policy'::regclass THEN (SELECT polrelid FROM pg_policy WHERE oid = d.objoid)
+                             END) IN (__SCHEMAS__)
+          OR (d.classoid = 'pg_namespace'::regclass
+              AND d.objoid IN (SELECT oid FROM pg_namespace WHERE nspname IN (__SCHEMAS__))))
+     AND NOT EXISTS (SELECT 1 FROM pg_depend e
+                      WHERE e.deptype = 'e' AND e.classid = d.classoid AND e.objid = d.objoid)
+
+) entries;