@intentius/chant-lexicon-sql 0.124.18 → 0.124.21

package/src/postgres/kinds.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Composite and range types, aggregates, collations, casts and event triggers
+ * (#3911): what the tags parse and refuse, how a change to each is
+ * classified and made, and how an import writes them.
+ */
+
+import { describe, expect, test } from "vitest";
+import { aggregate, cast, collation, eventTrigger, func, schema, SqlTemplateError, type } from "./entities";
+import { diffObject, keyedByQualifiedName, pgSchemaFromLive, type PgSchemaObject } from "./plan/schema";
+import { diffPgSchemas, matchPgObjects } from "./plan/diff";
+import { alterSteps, dropStatement } from "./apply/statements";
+import { declaredObjects } from "./apply/apply";
+import type { LivePgObject } from "./live/catalog";
+import { objectsToIR } from "./import/ir";
+import { PostgresGenerator } from "./import/generator";
+import { canonicalPgObject } from "./plan/normalize";
+
+const app = schema`CREATE SCHEMA app`;
+
+describe("the tags", () => {
+  test("type declares enum, composite and range types", () => {
+    const pair = type`CREATE TYPE ${app}.pair AS (a int, b text COLLATE "C"); COMMENT ON TYPE ${app}.pair IS 'Two'`;
+    expect(pair.entityType).toBe("Postgres::CompositeType");
+    expect(pair.props).toMatchObject({ schema: "app", name: "pair", attributes: [{ name: "a", type: "int" }, { name: "b", type: "text", collate: '"C"' }], comment: "Two" });
+    const range = type`CREATE TYPE ${app}.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi)`;
+    expect(range.entityType).toBe("Postgres::RangeType");
+    expect(canonicalPgObject(range.entityType, range.props as unknown as Record<string, unknown>).fields).toMatchObject({ subtype: "double precision", subtypeDiff: "float8mi", multirange: "app.floatmultirange" });
+    expect(type`CREATE TYPE ${app}.mood AS ENUM ('ok')`.entityType).toBe("Postgres::Enum");
+  });
+
+  test("an aggregate is identified by its argument types; its options compare canonical", () => {
+    const add = func`CREATE FUNCTION ${app}.add2(a int, b int) RETURNS int LANGUAGE sql AS $$ SELECT a + b $$`;
+    const total = aggregate`CREATE AGGREGATE ${app}.total(int) (SFUNC = ${add}, STYPE = int4, INITCOND = 0, PARALLEL = UNSAFE)`;
+    expect(total.dependsOn).toContain(add);
+    const c = canonicalPgObject(total.entityType, total.props as unknown as Record<string, unknown>);
+    expect(c.signature).toBe("(integer)");
+    expect(c.fields.definition).toEqual({ initcond: "0", sfunc: "app.add2", stype: "integer" });
+    const median = aggregate`CREATE AGGREGATE app.med(ORDER BY float8) (SFUNC = pg_catalog.array_append, STYPE = float8[])`;
+    expect(canonicalPgObject(median.entityType, median.props as unknown as Record<string, unknown>).signature).toBe("(ORDER BY double precision)");
+    expect(canonicalPgObject("Postgres::Aggregate", aggregate`CREATE AGGREGATE app.n(*) (SFUNC = int8inc, STYPE = int8)`.props as unknown as Record<string, unknown>).signature).toBe("(*)");
+  });
+
+  test("a collation, a cast and an event trigger", () => {
+    const ci = collation`CREATE COLLATION ${app}.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false)`;
+    expect(canonicalPgObject(ci.entityType, ci.props as unknown as Record<string, unknown>).fields).toMatchObject({ provider: "icu", locale: "und-u-ks-level2", nondeterministic: true });
+    const c2 = collation`CREATE COLLATION app.c2 (LOCALE = 'C')`;
+    expect(canonicalPgObject(c2.entityType, c2.props as unknown as Record<string, unknown>).fields).toMatchObject({ provider: "libc", lcCollate: "C", lcCtype: "C" });
+
+    const pair = type`CREATE TYPE ${app}.pair AS (a int)`;
+    const k = cast`CREATE CAST (${pair} AS text) WITH INOUT AS ASSIGNMENT; COMMENT ON CAST (${pair} AS text) IS 'x'`;
+    expect(k.sqlName).toBe("(app.pair AS text)");
+    expect(k.props).toMatchObject({ sourceType: "app.pair", targetType: "text", method: "inout", context: "assignment", comment: "x" });
+    expect(k.dependsOn).toEqual([pair]);
+
+    const fn = func`CREATE FUNCTION ${app}.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$`;
+    const et = eventTrigger`CREATE EVENT TRIGGER audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE', 'alter table') EXECUTE FUNCTION ${fn}()`;
+    expect(canonicalPgObject(et.entityType, et.props as unknown as Record<string, unknown>).fields).toMatchObject({ event: "ddl_command_end", tags: ["ALTER TABLE", "CREATE TABLE"], function: "app.audit" });
+  });
+
+  test("what is refused", () => {
+    expect(() => type`CREATE TYPE app.later`).toThrow(/shell type/);
+    expect(() => type`CREATE TYPE app.t (INPUT = t_in, OUTPUT = t_out)`).toThrow(/base type/);
+    expect(() => aggregate`CREATE AGGREGATE app.a (BASETYPE = int, SFUNC = f, STYPE = int)`).toThrow(/old form/);
+    expect(() => aggregate`CREATE AGGREGATE app.a(int) (SFUNC = f)`).toThrow(/expected STYPE/);
+    expect(() => aggregate`CREATE AGGREGATE app.a(OUT int) (SFUNC = f, STYPE = int)`).toThrow(/IN or VARIADIC/);
+    expect(() => collation`CREATE COLLATION app.c FROM "C"`).toThrow(/FROM copies/);
+    expect(() => collation`CREATE COLLATION app.c (lokale = 'C')`).toThrow(/an option of a collation/);
+    expect(() => type`CREATE TYPE app.r AS RANGE (SUBTYPE_DIFF = f)`).toThrow(/expected SUBTYPE/);
+    expect(() => eventTrigger`CREATE EVENT TRIGGER app.e ON ddl_command_end EXECUTE FUNCTION f()`).toThrow(/not schema-qualified/);
+    expect(() => cast`CREATE CAST (int AS text) WITH INOUT; COMMENT ON CAST (int AS bigint) IS 'x'`).toThrow(/another cast/);
+    expect(() => collation`CREATE TABLE app.t (a int)`).toThrow(SqlTemplateError);
+  });
+});
+
+// ── Classifying and making changes ─────────────────────────────────────
+
+const live = (type: string, statement: string, extra: Partial<LivePgObject> = {}) => pgSchemaFromLive([{ type, statement, name: "", oid: "1", ...extra } as LivePgObject], "public");
+const declared = (type: string, ddl: string): PgSchemaObject[] => keyedByQualifiedName([{ key: "x", canonical: { ...diffObject(type, ddl, "public"), exportName: "x" } }]);
+const rules = (type: string, before: string, after: string, extra: Partial<LivePgObject> = {}) =>
+  diffPgSchemas(live(type, before, extra), declared(type, after)).changes.map((c) => [c.field, c.rule]);
+
+const AGG = "Postgres::Aggregate";
+const AGG1 = "CREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0')";
+
+function steps(type: string, liveDdl: string, declaredDdl: string, extra: Partial<LivePgObject> = {}): string[] {
+  const [obj] = declaredObjects(JSON.stringify({ dialect: "postgres", objects: [{ export: "x", type, ddl: declaredDdl, dependsOn: [] }] }));
+  const after = keyedByQualifiedName([{ key: "x", canonical: obj!.canonical }]);
+  const before = live(type, liveDdl, extra);
+  const m = matchPgObjects(before, after).find((x) => x.kind === "matched")!;
+  return alterSteps(obj!, m.before!.canonical, diffPgSchemas(before, after).changes, { major: 18 }).steps.map((s) => s.sql);
+}
+
+describe("the classifier and the statements", () => {
+  test("the server's printing is the declaration's", () => {
+    expect(rules(AGG, AGG1, "CREATE AGGREGATE app.total(int) (sfunc = app.add2, stype = int4, initcond = 0, parallel = unsafe)")).toEqual([]);
+    expect(rules("Postgres::CompositeType", "CREATE TYPE app.pair AS (\n    a integer,\n    b text COLLATE \"C\"\n)", "CREATE TYPE app.pair AS (a int, b text COLLATE pg_catalog.\"C\")")).toEqual([]);
+    expect(rules("Postgres::Cast", "CREATE CAST (app.pair AS text) WITH FUNCTION app.f(app.pair)", "CREATE CAST (app.pair AS text) WITH FUNCTION app.f")).toEqual([]);
+  });
+
+  test("an aggregate's options are replaced in place; its state type is a drop and a create, refused while something depends on it", () => {
+    expect(rules(AGG, AGG1, AGG1.replace("'0'", "'1'"))).toEqual([["definition", "SQLPG302"]]);
+    expect(steps(AGG, AGG1, AGG1.replace("'0'", "'1'"))).toEqual([AGG1.replace("CREATE ", "CREATE OR REPLACE ").replace("'0'", "'1'")]);
+    expect(rules(AGG, AGG1, AGG1.replace("STYPE = integer", "STYPE = bigint"))).toEqual([["definition", "SQLPG300"]]);
+    expect(rules(AGG, AGG1, AGG1.replace("STYPE = integer", "STYPE = bigint"), { dependents: ["view app.v"] })).toEqual([["definition", "SQLPG301"]]);
+    const recreate = steps(AGG, AGG1, AGG1.replace("STYPE = integer", "STYPE = bigint"));
+    expect(recreate[0]).toBe("DROP AGGREGATE app.total(integer)");
+    expect(recreate[2]).toMatch(/^COMMENT ON AGGREGATE app\.total\(integer\) IS /);
+  });
+
+  test("a cast, an event trigger, a collation and a type are dropped and created", () => {
+    const C1 = "CREATE CAST (app.pair AS text) WITH INOUT";
+    expect(steps("Postgres::Cast", C1, `${C1} AS IMPLICIT`).slice(0, 2)).toEqual(["DROP CAST (app.pair AS text)", `${C1} AS IMPLICIT`]);
+    const E1 = "CREATE EVENT TRIGGER e ON ddl_command_end EXECUTE FUNCTION app.f()";
+    expect(steps("Postgres::EventTrigger", E1, E1.replace("ddl_command_end", "sql_drop"))[0]).toBe("DROP EVENT TRIGGER e");
+    expect(rules("Postgres::Collation", "CREATE COLLATION app.c (LOCALE = 'C')", "CREATE COLLATION app.c (LOCALE = 'POSIX')", { dependents: ["column nick of table app.people"] })).toEqual([["lcCollate, lcCtype", "SQLPG301"]]);
+    expect(rules("Postgres::RangeType", "CREATE TYPE app.r AS RANGE (SUBTYPE = integer)", "CREATE TYPE app.r AS RANGE (SUBTYPE = bigint)")).toEqual([["subtype", "SQLPG300"]]);
+    expect(dropStatement("cast", undefined, "(a AS b)").sql).toBe("DROP CAST (a AS b)");
+    expect(dropStatement("composite", "app", "pair").sql).toBe("DROP TYPE app.pair");
+  });
+
+  test("a comment changes in place", () => {
+    expect(steps("Postgres::Collation", "CREATE COLLATION app.c (LOCALE = 'C')", "CREATE COLLATION app.c (LOCALE = 'C'); COMMENT ON COLLATION app.c IS 'c'")).toEqual([expect.stringMatching(/^COMMENT ON COLLATION app\.c IS 'c/)]);
+  });
+});
+
+describe("importing", () => {
+  test("each kind is written with its tag, its references interpolated", () => {
+    const content = new PostgresGenerator().generate(
+      objectsToIR([
+        { type: "Postgres::CompositeType", schema: "app", name: "pair", ddl: "CREATE TYPE app.pair AS (a integer)" },
+        { type: "Postgres::Function", schema: "app", name: "pair_text", ddl: "CREATE OR REPLACE FUNCTION app.pair_text(p app.pair)\n RETURNS text\n LANGUAGE sql\nAS $function$ SELECT '' $function$" },
+        { type: "Postgres::Cast", name: "(app.pair AS text)", ddl: "CREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair)" },
+        { type: "Postgres::Aggregate", schema: "app", name: "n", ddl: "CREATE AGGREGATE app.n(*) (SFUNC = int8inc, STYPE = bigint)" },
+      ]),
+    )[0]!.content;
+    expect(content).toContain('import { aggregate, cast, func, type } from "@intentius/chant-lexicon-sql/postgres";');
+    expect(content).toContain("CREATE CAST (${pair} AS text) WITH FUNCTION ${pairText}(${pair})");
+    expect(content).toContain("export const n = aggregate`");
+  });
+});

package/src/postgres/live/catalog-kinds.ts

@@ -0,0 +1,312 @@
+/**
+ * The catalog read of the kinds #3911 adds: composite and range types,
+ * collations, aggregates, casts and event triggers. Postgres has no printer
+ * for any of them (`pg_dump` assembles each from its catalog row), so the
+ * statement is assembled here the same way: `format_type()` for every type,
+ * `regproc` for every function (bare in `pg_catalog`, qualified elsewhere,
+ * since the session's search_path is empty), and an option only where it is
+ * not what Postgres would choose by itself, so the printed form is the
+ * canonical one a declaration is compared with (`../plan/normalize.ts`).
+ *
+ * Left out, each for its reason: a table's row type (the table is its
+ * declaration), a multirange type (its range type creates it), an object an
+ * extension owns, and a cast the server defines (`oid` below 16384, the first
+ * normal object id).
+ *
+ * Each object carries what depends on it (`pg_depend`, a normal dependency),
+ * which a DROP refuses over, so a change the plan would make by dropping and
+ * creating it is refused instead (SQLPG301).
+ */
+
+import type { PostgresClient } from "./client";
+import { notExtensionOwned, scopeSql, type LivePgObject, type SchemaScope } from "./catalog";
+import { POSTGRES_ENTITY_TYPES } from "../entity-types";
+import { quoteIdent } from "../keywords";
+import { stripMarker } from "../../core/ownership";
+
+type Row = Record<string, unknown>;
+
+const C = 'COLLATE "C"';
+const str = (v: unknown): string | undefined => (v === null || v === undefined ? undefined : String(v));
+const literal = (s: string): string => `'${s.replace(/'/g, "''")}'`;
+const qname = (schema: string, name: string): string => `${quoteIdent(schema)}.${quoteIdent(name)}`;
+
+function commentOn(what: string, comment: unknown): string[] {
+  const c = str(comment);
+  if (c === undefined) return [];
+  const own = stripMarker(c);
+  return own === "" ? [] : [`COMMENT ON ${what} IS ${literal(own)}`];
+}
+
+const notInternal = (catalog: string, oid: string): string =>
+  `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_catalog.${catalog}'::pg_catalog.regclass AND d.objid = ${oid} AND d.deptype = 'i')`;
+
+/** What depends on an object of catalog `catalog` (a normal dependency), as the server describes each. */
+const dependentsOf = (catalog: string, oid: string): string =>
+  `ARRAY(SELECT pg_catalog.pg_describe_object(d.classid, d.objid, d.objsubid) FROM pg_catalog.pg_depend d
+         WHERE d.refclassid = 'pg_catalog.${catalog}'::pg_catalog.regclass AND d.refobjid = ${oid} AND d.deptype = 'n' ORDER BY 1)`;
+
+/** A collation's name as a clause: a `pg_catalog` one bare. */
+const collationName = (oid: string): string =>
+  `(SELECT CASE WHEN cn.nspname = 'pg_catalog' THEN pg_catalog.quote_ident(co.collname) ELSE pg_catalog.quote_ident(cn.nspname) || '.' || pg_catalog.quote_ident(co.collname) END ` +
+  `FROM pg_catalog.pg_collation co JOIN pg_catalog.pg_namespace cn ON cn.oid = co.collnamespace WHERE co.oid = ${oid})`;
+
+/** A function named by a `regproc` column, or nothing for 0 (which `regproc` prints as `-`). */
+const proc = (column: string): string => `NULLIF(${column}::text, '-')`;
+
+const dependents = (r: Row): { dependents?: string[] } => {
+  const d = (r.dependents as string[] | null) ?? [];
+  return d.length > 0 ? { dependents: d } : {};
+};
+
+const withComment = (r: Row): { comment?: string } => (str(r.comment) ? { comment: str(r.comment)! } : {});
+
+/** Composite and range types: read where the enums are, before the domains and tables that may use them. */
+export async function readTypeKinds(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const out: LivePgObject[] = [];
+  const s = scopeSql("n.nspname", scope);
+
+  // Composite types: the standalone ones, not a table's or a view's row type.
+  const composites = await client.query<Row>(
+    `SELECT t.oid::text AS oid, n.nspname AS schema, t.typname AS name, pg_catalog.obj_description(t.oid, 'pg_type') AS comment,
+            ARRAY(SELECT pg_catalog.quote_ident(a.attname) || ' ' || pg_catalog.format_type(a.atttypid, a.atttypmod) ||
+                         CASE WHEN a.attcollation <> 0 AND a.attcollation <> at.typcollation THEN ' COLLATE ' || ${collationName("a.attcollation")} ELSE '' END
+                  FROM pg_catalog.pg_attribute AS a JOIN pg_catalog.pg_type at ON at.oid = a.atttypid
+                  WHERE a.attrelid = t.typrelid AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum) AS attributes,
+            ${dependentsOf("pg_type", "t.oid")} AS dependents
+     FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace JOIN pg_catalog.pg_class c ON c.oid = t.typrelid
+     WHERE t.typtype = 'c' AND c.relkind = 'c' AND ${s.sql} AND ${notExtensionOwned("pg_type", "t.oid")}
+     ORDER BY n.nspname ${C}, t.typname ${C}`,
+    s.params,
+  );
+  for (const r of composites) {
+    const q = qname(String(r.schema), String(r.name));
+    const attributes = (r.attributes as string[] | null) ?? [];
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.composite,
+      schema: String(r.schema),
+      name: String(r.name),
+      oid: String(r.oid),
+      ...withComment(r),
+      ...dependents(r),
+      statement: [`CREATE TYPE ${q} AS (${attributes.length > 0 ? `\n    ${attributes.join(",\n    ")}\n` : ""})`, ...commentOn(`TYPE ${q}`, r.comment)].join(";\n"),
+    });
+  }
+
+  // Range types, each with the options that differ from what CREATE TYPE ... AS RANGE would choose.
+  const ranges = await client.query<Row>(
+    `SELECT t.oid::text AS oid, n.nspname AS schema, t.typname AS name, pg_catalog.obj_description(t.oid, 'pg_type') AS comment,
+            pg_catalog.format_type(r.rngsubtype, NULL) AS subtype,
+            CASE WHEN r.rngsubopc <> (SELECT o.oid FROM pg_catalog.pg_opclass o JOIN pg_catalog.pg_am am ON am.oid = o.opcmethod
+                                      WHERE am.amname = 'btree' AND o.opcintype = r.rngsubtype AND o.opcdefault LIMIT 1)
+                 THEN (SELECT CASE WHEN on2.nspname = 'pg_catalog' THEN pg_catalog.quote_ident(o.opcname) ELSE pg_catalog.quote_ident(on2.nspname) || '.' || pg_catalog.quote_ident(o.opcname) END
+                       FROM pg_catalog.pg_opclass o JOIN pg_catalog.pg_namespace on2 ON on2.oid = o.opcnamespace WHERE o.oid = r.rngsubopc) END AS opclass,
+            CASE WHEN r.rngcollation <> 0 AND r.rngcollation <> st.typcollation THEN ${collationName("r.rngcollation")} END AS collation,
+            ${proc("r.rngcanonical")} AS canonical, ${proc("r.rngsubdiff")} AS subdiff,
+            mn.nspname AS multi_schema, mt.typname AS multi_name,
+            ${dependentsOf("pg_type", "t.oid")} AS dependents
+     FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace JOIN pg_catalog.pg_range r ON r.rngtypid = t.oid
+     JOIN pg_catalog.pg_type st ON st.oid = r.rngsubtype
+     JOIN pg_catalog.pg_type mt ON mt.oid = r.rngmultitypid JOIN pg_catalog.pg_namespace mn ON mn.oid = mt.typnamespace
+     WHERE t.typtype = 'r' AND ${s.sql} AND ${notExtensionOwned("pg_type", "t.oid")}
+     ORDER BY n.nspname ${C}, t.typname ${C}`,
+    s.params,
+  );
+  for (const r of ranges) {
+    const schema = String(r.schema);
+    const name = String(r.name);
+    const q = qname(schema, name);
+    const opts = [`SUBTYPE = ${r.subtype}`];
+    if (str(r.opclass)) opts.push(`SUBTYPE_OPCLASS = ${r.opclass}`);
+    if (str(r.collation)) opts.push(`COLLATION = ${r.collation}`);
+    if (str(r.canonical)) opts.push(`CANONICAL = ${r.canonical}`);
+    if (str(r.subdiff)) opts.push(`SUBTYPE_DIFF = ${r.subdiff}`);
+    // The multirange type's name, when it is not the one Postgres derives in the range's schema.
+    const at = name.indexOf("range");
+    const derived = at >= 0 ? `${name.slice(0, at)}multi${name.slice(at)}` : `${name}_multirange`;
+    if (String(r.multi_schema) !== schema || String(r.multi_name) !== derived) opts.push(`MULTIRANGE_TYPE_NAME = ${qname(String(r.multi_schema), String(r.multi_name))}`);
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.range,
+      schema,
+      name,
+      oid: String(r.oid),
+      ...withComment(r),
+      ...dependents(r),
+      statement: [`CREATE TYPE ${q} AS RANGE (${opts.join(", ")})`, ...commentOn(`TYPE ${q}`, r.comment)].join(";\n"),
+    });
+  }
+  return out;
+}
+
+/** Collations: read first, before the types and tables whose columns use them. */
+export async function readCollations(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const s = scopeSql("n.nspname", scope);
+  const rows = await client.query<Row>(
+    `SELECT c.oid::text AS oid, n.nspname AS schema, c.collname AS name, pg_catalog.to_jsonb(c) AS def,
+            pg_catalog.obj_description(c.oid, 'pg_collation') AS comment, ${dependentsOf("pg_collation", "c.oid")} AS dependents
+     FROM pg_catalog.pg_collation c JOIN pg_catalog.pg_namespace n ON n.oid = c.collnamespace
+     WHERE ${s.sql} AND ${notExtensionOwned("pg_collation", "c.oid")}
+     ORDER BY n.nspname ${C}, c.collname ${C}`,
+    s.params,
+  );
+  const out: LivePgObject[] = [];
+  for (const r of rows) {
+    // The row as JSON: its columns differ across the majors (`colliculocale` in 15 and 16, `colllocale` from 17, `collicurules` from 16).
+    const d = (typeof r.def === "string" ? JSON.parse(r.def) : r.def) as Record<string, unknown>;
+    const provider = ({ c: "libc", i: "icu", b: "builtin", d: "default" } as Record<string, string>)[String(d.collprovider)] ?? "libc";
+    const locale = str(d.colllocale) ?? str(d.colliculocale);
+    const opts: string[] = [];
+    if (provider !== "libc") opts.push(`PROVIDER = ${provider}`);
+    if (provider === "libc" || locale === undefined) {
+      const collate = str(d.collcollate) ?? "";
+      const ctype = str(d.collctype) ?? "";
+      if (provider !== "libc") opts.push(`LOCALE = ${literal(collate)}`);
+      else if (collate === ctype) opts.push(`LOCALE = ${literal(collate)}`);
+      else opts.push(`LC_COLLATE = ${literal(collate)}`, `LC_CTYPE = ${literal(ctype)}`);
+    } else opts.push(`LOCALE = ${literal(locale)}`);
+    if (d.collisdeterministic === false) opts.push("DETERMINISTIC = false");
+    if (str(d.collicurules)) opts.push(`RULES = ${literal(String(d.collicurules))}`);
+    const q = qname(String(r.schema), String(r.name));
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.collation,
+      schema: String(r.schema),
+      name: String(r.name),
+      oid: String(r.oid),
+      ...withComment(r),
+      ...dependents(r),
+      statement: [`CREATE COLLATION ${q} (${opts.join(", ")})`, ...commentOn(`COLLATION ${q}`, r.comment)].join(";\n"),
+    });
+  }
+  return out;
+}
+
+const MODIFY: Record<string, string> = { r: "READ_ONLY", s: "SHAREABLE", w: "READ_WRITE" };
+
+/** Aggregates, casts and event triggers: read after the functions they call. */
+export async function readRoutineKinds(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const out: LivePgObject[] = [];
+  const s = scopeSql("n.nspname", scope);
+
+  const aggregates = await client.query<Row>(
+    `SELECT p.oid::text AS oid, n.nspname AS schema, p.proname AS name, pg_catalog.pg_get_function_arguments(p.oid) AS args,
+            ARRAY(SELECT pg_catalog.format_type(u.x, NULL) FROM pg_catalog.unnest(p.proargtypes::pg_catalog.oid[]) WITH ORDINALITY AS u(x, i) ORDER BY u.i) AS argtypes,
+            a.aggkind AS kind, a.aggnumdirectargs AS ndirect,
+            ${proc("a.aggtransfn")} AS sfunc, pg_catalog.format_type(a.aggtranstype, NULL) AS stype, a.aggtransspace AS sspace,
+            ${proc("a.aggfinalfn")} AS finalfunc, a.aggfinalextra AS finalextra, a.aggfinalmodify::text AS finalmodify,
+            ${proc("a.aggcombinefn")} AS combinefunc, ${proc("a.aggserialfn")} AS serialfunc, ${proc("a.aggdeserialfn")} AS deserialfunc,
+            a.agginitval AS initcond,
+            ${proc("a.aggmtransfn")} AS msfunc, ${proc("a.aggminvtransfn")} AS minvfunc,
+            CASE WHEN a.aggmtranstype <> 0 THEN pg_catalog.format_type(a.aggmtranstype, NULL) END AS mstype, a.aggmtransspace AS msspace,
+            ${proc("a.aggmfinalfn")} AS mfinalfunc, a.aggmfinalextra AS mfinalextra, a.aggmfinalmodify::text AS mfinalmodify, a.aggminitval AS minitcond,
+            CASE WHEN a.aggsortop <> 0 THEN (SELECT CASE WHEN opn.nspname = 'pg_catalog' THEN o.oprname ELSE 'OPERATOR(' || pg_catalog.quote_ident(opn.nspname) || '.' || o.oprname || ')' END
+                                              FROM pg_catalog.pg_operator o JOIN pg_catalog.pg_namespace opn ON opn.oid = o.oprnamespace WHERE o.oid = a.aggsortop) END AS sortop,
+            p.proparallel AS parallel, pg_catalog.obj_description(p.oid, 'pg_proc') AS comment,
+            ${dependentsOf("pg_proc", "p.oid")} AS dependents
+     FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace JOIN pg_catalog.pg_aggregate a ON a.aggfnoid = p.oid
+     WHERE p.prokind = 'a' AND ${s.sql} AND ${notExtensionOwned("pg_proc", "p.oid")}
+     ORDER BY n.nspname ${C}, p.proname ${C}, pg_catalog.oidvectortypes(p.proargtypes) ${C}`,
+    s.params,
+  );
+  for (const r of aggregates) {
+    const kind = String(r.kind);
+    const types = (r.argtypes as string[] | null) ?? [];
+    const ndirect = Number(r.ndirect ?? 0);
+    const signature =
+      kind === "n"
+        ? `(${types.length === 0 ? "*" : types.join(",")})`
+        : `(${ndirect > 0 ? `${types.slice(0, ndirect).join(",")} ` : ""}ORDER BY ${types.slice(ndirect).join(",")})`;
+    const args = str(r.args) || "*";
+    const modifyDefault = kind === "n" ? "r" : "w";
+    const opts = [`SFUNC = ${r.sfunc}`, `STYPE = ${r.stype}`];
+    if (Number(r.sspace) !== 0) opts.push(`SSPACE = ${Number(r.sspace)}`);
+    if (str(r.finalfunc)) opts.push(`FINALFUNC = ${r.finalfunc}`);
+    if (r.finalextra === true) opts.push("FINALFUNC_EXTRA");
+    if (str(r.finalmodify) && r.finalmodify !== modifyDefault) opts.push(`FINALFUNC_MODIFY = ${MODIFY[String(r.finalmodify)]}`);
+    if (str(r.combinefunc)) opts.push(`COMBINEFUNC = ${r.combinefunc}`);
+    if (str(r.serialfunc)) opts.push(`SERIALFUNC = ${r.serialfunc}`);
+    if (str(r.deserialfunc)) opts.push(`DESERIALFUNC = ${r.deserialfunc}`);
+    if (str(r.initcond) !== undefined) opts.push(`INITCOND = ${literal(String(r.initcond))}`);
+    if (str(r.msfunc)) {
+      opts.push(`MSFUNC = ${r.msfunc}`);
+      if (str(r.minvfunc)) opts.push(`MINVFUNC = ${r.minvfunc}`);
+      if (str(r.mstype)) opts.push(`MSTYPE = ${r.mstype}`);
+      if (Number(r.msspace) !== 0) opts.push(`MSSPACE = ${Number(r.msspace)}`);
+      if (str(r.mfinalfunc)) opts.push(`MFINALFUNC = ${r.mfinalfunc}`);
+      if (r.mfinalextra === true) opts.push("MFINALFUNC_EXTRA");
+      if (str(r.mfinalmodify) && r.mfinalmodify !== modifyDefault) opts.push(`MFINALFUNC_MODIFY = ${MODIFY[String(r.mfinalmodify)]}`);
+      if (str(r.minitcond) !== undefined) opts.push(`MINITCOND = ${literal(String(r.minitcond))}`);
+    }
+    if (str(r.sortop)) opts.push(`SORTOP = ${r.sortop}`);
+    if (r.parallel === "s") opts.push("PARALLEL = SAFE");
+    else if (r.parallel === "r") opts.push("PARALLEL = RESTRICTED");
+    if (kind === "h") opts.push("HYPOTHETICAL");
+    const q = qname(String(r.schema), String(r.name));
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.aggregate,
+      schema: String(r.schema),
+      name: String(r.name),
+      oid: String(r.oid),
+      signature,
+      ...withComment(r),
+      ...dependents(r),
+      statement: [`CREATE AGGREGATE ${q}(${args}) (${opts.join(", ")})`, ...commentOn(`AGGREGATE ${q}(${args})`, r.comment)].join(";\n"),
+    });
+  }
+
+  // Casts the database defines: the server's own have oids below the first normal object id. In scope when a type or the function is.
+  const scoped = (column: string) =>
+    scope.schemas
+      ? `(SELECT xn.nspname FROM pg_catalog.pg_type x JOIN pg_catalog.pg_namespace xn ON xn.oid = x.typnamespace WHERE x.oid = ${column}) = ANY($1::text[])`
+      : "true";
+  const casts = await client.query<Row>(
+    `SELECT c.oid::text AS oid, pg_catalog.format_type(c.castsource, NULL) AS source, pg_catalog.format_type(c.casttarget, NULL) AS target,
+            c.castmethod::text AS method, c.castcontext::text AS context,
+            CASE WHEN c.castfunc <> 0 THEN c.castfunc::pg_catalog.regprocedure::text END AS func,
+            pg_catalog.obj_description(c.oid, 'pg_cast') AS comment, ${dependentsOf("pg_cast", "c.oid")} AS dependents
+     FROM pg_catalog.pg_cast c
+     WHERE c.oid >= 16384 AND ${notExtensionOwned("pg_cast", "c.oid")} AND ${notInternal("pg_cast", "c.oid")}
+       AND (${scoped("c.castsource")} OR ${scoped("c.casttarget")}
+            OR ${scope.schemas ? `(SELECT pn.nspname FROM pg_catalog.pg_proc pp JOIN pg_catalog.pg_namespace pn ON pn.oid = pp.pronamespace WHERE pp.oid = c.castfunc) = ANY($1::text[])` : "true"})
+     ORDER BY pg_catalog.format_type(c.castsource, NULL) ${C}, pg_catalog.format_type(c.casttarget, NULL) ${C}`,
+    scope.schemas ? [[...scope.schemas]] : [],
+  );
+  for (const r of casts) {
+    const name = `(${r.source} AS ${r.target})`;
+    const how = r.method === "b" ? "WITHOUT FUNCTION" : r.method === "i" ? "WITH INOUT" : `WITH FUNCTION ${r.func}`;
+    const context = r.context === "a" ? " AS ASSIGNMENT" : r.context === "i" ? " AS IMPLICIT" : "";
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.cast,
+      name,
+      oid: String(r.oid),
+      ...withComment(r),
+      ...dependents(r),
+      statement: [`CREATE CAST ${name} ${how}${context}`, ...commentOn(`CAST ${name}`, r.comment)].join(";\n"),
+    });
+  }
+
+  // Event triggers: the database's, in scope when their function is.
+  const fs = scopeSql("fn.nspname", scope);
+  const events = await client.query<Row>(
+    `SELECT e.oid::text AS oid, e.evtname AS name, e.evtevent AS event, ${proc("e.evtfoid::pg_catalog.regproc")} AS func, e.evttags AS tags,
+            pg_catalog.obj_description(e.oid, 'pg_event_trigger') AS comment
+     FROM pg_catalog.pg_event_trigger e JOIN pg_catalog.pg_proc f ON f.oid = e.evtfoid JOIN pg_catalog.pg_namespace fn ON fn.oid = f.pronamespace
+     WHERE ${fs.sql} AND ${notExtensionOwned("pg_event_trigger", "e.oid")}
+     ORDER BY e.evtname ${C}`,
+    fs.params,
+  );
+  for (const r of events) {
+    const name = quoteIdent(String(r.name));
+    const tags = (r.tags as string[] | null) ?? [];
+    out.push({
+      type: POSTGRES_ENTITY_TYPES.eventTrigger,
+      name: String(r.name),
+      oid: String(r.oid),
+      ...withComment(r),
+      statement: [
+        `CREATE EVENT TRIGGER ${name} ON ${quoteIdent(String(r.event))}${tags.length > 0 ? ` WHEN TAG IN (${tags.map(literal).join(", ")})` : ""} EXECUTE FUNCTION ${r.func}()`,
+        ...commentOn(`EVENT TRIGGER ${name}`, r.comment),
+      ].join(";\n"),
+    });
+  }
+  return out;
+}

package/src/postgres/live/catalog.ts

@@ -18,8 +18,11 @@
  * - objects an extension owns (`pg_depend.deptype = 'e'`): the extension
  *   declares them, so the extension is what is imported;
  * - `plpgsql`, installed in every database;
- * - aggregates, and a trigger the server makes for itself (a foreign key's)
- *   or clones onto a partition from its parent's;
+ * - a trigger the server makes for itself (a foreign key's) or clones onto a
+ *   partition from its parent's, and a function or cast that is part of
+ *   another object (a range type's constructors and its multirange cast);
+ * - a table's row type, a multirange type (its range type creates it), and a
+ *   cast the server defines (`./catalog-kinds.ts`);
  * - a routine with a SQL-standard body (`RETURN`, `BEGIN ATOMIC`): read, but
  *   marked `unsupported`, since the server prints it rewritten and a
  *   declaration cannot hold it;
@@ -32,6 +35,10 @@
  *   progress (`../migrate/names.ts`, `../migrate/carry.ts`), so a table reads
  *   as it was before the migration until its switch, and as declared after it.
  *
+ * Objects of the kinds no declaration holds (operators, publications, rules,
+ * ...) are not read here: import finds them with `./undeclarable.ts` and
+ * refuses them by name (#3911).
+ *
  * Objects another tool owns, an ORM's or a migration runner's revision table
  * ({@link FOREIGN_TABLES}), are read and marked with the tool, so import
  * leaves them out with a warning and observation reports them foreign, never
@@ -46,6 +53,7 @@ import { MIGRATION_TRAILER_KEY } from "../migrate/names";
 import { isProviderOwned, providerData } from "../providers";
 import { FOREIGN_TABLES } from "../../core/foreign-tables";
 import type { PostgresProvider } from "../providers/types";
+import { readCollations, readRoutineKinds, readTypeKinds } from "./catalog-kinds";
 
 /** The server's own schemas, never part of a declared schema. */
 export const SYSTEM_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast"];
@@ -69,9 +77,9 @@ export interface LivePgObject {
   statement: string;
   /** The tool whose bookkeeping this is, when it is another tool's (an ORM's revision table). */
   foreign?: string;
-  /** A routine's input parameter types, `(integer,text)`; a trigger's table, ` ON app.users` (`../plan/normalize.ts`). */
+  /** A routine's or aggregate's input parameter types, `(integer,text)`; a trigger's table, ` ON app.users` (`../plan/normalize.ts`). */
   signature?: string;
-  /** What depends on a routine (a view, a trigger, a column default), as the server describes each. */
+  /** What depends on a routine, type, aggregate, collation or cast (a view, a trigger, a column), as the server describes each. */
   dependents?: string[];
   /** Why no declaration can hold this object; it is read so import can say it left it out. */
   unsupported?: string;
@@ -112,7 +120,7 @@ const commentOn = (what: string, comment: unknown): string[] => {
 };
 
 /** The scope as a predicate on a schema name column, with its parameter. */
-function scopeSql(column: string, scope: SchemaScope): { sql: string; params: unknown[] } {
+export function scopeSql(column: string, scope: SchemaScope): { sql: string; params: unknown[] } {
   if (scope.schemas) return { sql: `${column} = ANY($1::text[])`, params: [[...scope.schemas]] };
   return {
     sql: `${column} NOT IN ('pg_catalog', 'information_schema', 'pg_toast') AND ${column} NOT LIKE 'pg\\_temp\\_%' AND ${column} NOT LIKE 'pg\\_toast\\_temp\\_%'`,
@@ -121,9 +129,13 @@ function scopeSql(column: string, scope: SchemaScope): { sql: string; params: un
 }
 
 /** `NOT <object is owned by an extension>`, for an object of catalog `catalog` with oid column `oid`. */
-const notExtensionOwned = (catalog: string, oid: string): string =>
+export const notExtensionOwned = (catalog: string, oid: string): string =>
   `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_catalog.${catalog}'::pg_catalog.regclass AND d.objid = ${oid} AND d.deptype = 'e')`;
 
+/** `NOT <object is part of another>` (`pg_depend.deptype = 'i'`): a range type's constructor functions, its multirange cast. */
+const notInternal = (catalog: string, oid: string): string =>
+  `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_catalog.${catalog}'::pg_catalog.regclass AND d.objid = ${oid} AND d.deptype = 'i')`;
+
 /** A collation name as a clause, `pg_catalog` names unqualified. */
 const COLLATION_NAME = (oid: string) =>
   `(SELECT CASE WHEN cn.nspname = 'pg_catalog' THEN pg_catalog.quote_ident(co.collname) ELSE pg_catalog.quote_ident(cn.nspname) || '.' || pg_catalog.quote_ident(co.collname) END ` +
@@ -188,10 +200,11 @@ const seqParams = (r: Row): SequenceParams => ({
 // ── Reading ────────────────────────────────────────────────────────────
 
 /**
- * Every object in scope, in a stable order: schemas, extensions, enums,
- * domains, sequences, tables, views and materialized views, indexes,
- * functions and procedures, triggers, and where access is read, policies and
- * the declared roles; each kind by schema then name, in byte order.
+ * Every object in scope, in a stable order: schemas, extensions, collations,
+ * enums, composite and range types, domains, sequences, tables, views and
+ * materialized views, indexes, functions and procedures, aggregates, casts,
+ * event triggers, triggers, and where access is read, policies and the
+ * declared roles; each kind by schema then name, in byte order.
  */
 export async function readLiveSchema(client: PostgresClient, scope: SchemaScope = {}): Promise<LivePgObject[]> {
   const out: LivePgObject[] = [];
@@ -249,6 +262,9 @@ export async function readLiveSchema(client: PostgresClient, scope: SchemaScope
     }
   }
 
+  // Collations, before the types and columns that use them (#3911).
+  out.push(...(await readCollations(client, scope)));
+
   // Enums.
   {
     const s = scopeSql("n.nspname", scope);
@@ -273,6 +289,9 @@ export async function readLiveSchema(client: PostgresClient, scope: SchemaScope
     }
   }
 
+  // Composite and range types (#3911).
+  out.push(...(await readTypeKinds(client, scope)));
+
   // Domains.
   {
     const s = scopeSql("n.nspname", scope);
@@ -582,7 +601,7 @@ export async function readLiveSchema(client: PostgresClient, scope: SchemaScope
                     WHERE d.refclassid = 'pg_catalog.pg_proc'::pg_catalog.regclass AND d.refobjid = p.oid AND d.deptype = 'n'
                     ORDER BY 1) AS dependents
        FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-       WHERE p.prokind IN ('f', 'p', 'w') AND ${s.sql} AND ${notExtensionOwned("pg_proc", "p.oid")}
+       WHERE p.prokind IN ('f', 'p', 'w') AND ${s.sql} AND ${notExtensionOwned("pg_proc", "p.oid")} AND ${notInternal("pg_proc", "p.oid")}
        ORDER BY n.nspname ${C}, p.proname ${C}, pg_catalog.oidvectortypes(p.proargtypes) ${C}`,
       s.params,
     );
@@ -607,6 +626,9 @@ export async function readLiveSchema(client: PostgresClient, scope: SchemaScope
     }
   }
 
+  // Aggregates, casts and event triggers, after the functions they call (#3911).
+  out.push(...(await readRoutineKinds(client, scope)));
+
   // Triggers: the ones written by hand, not a foreign key's or a partition's clone of its parent's.
   {
     const rows = await client.query<Row>(

package/src/postgres/live/describe-resources.ts

@@ -41,9 +41,17 @@ interface Bound {
  */
 export function declaredAddress(entity: { type: string; props: Record<string, unknown> }, defaultSchema: string): { schema?: string; name: string; signature?: string } {
   const name = String(entity.props.name ?? "");
-  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role) return { name };
+  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role || entity.type === POSTGRES_ENTITY_TYPES.eventTrigger) return { name };
+  // A cast is named by its two types, as the catalog prints them.
+  if (entity.type === POSTGRES_ENTITY_TYPES.cast) return { name: canonicalPgObject(entity.type, entity.props, defaultSchema).name };
   const schema = typeof entity.props.schema === "string" ? entity.props.schema : identValue(defaultSchema);
-  if (entity.type === POSTGRES_ENTITY_TYPES.function || entity.type === POSTGRES_ENTITY_TYPES.procedure || entity.type === POSTGRES_ENTITY_TYPES.trigger || entity.type === POSTGRES_ENTITY_TYPES.policy) {
+  if (
+    entity.type === POSTGRES_ENTITY_TYPES.function ||
+    entity.type === POSTGRES_ENTITY_TYPES.procedure ||
+    entity.type === POSTGRES_ENTITY_TYPES.aggregate ||
+    entity.type === POSTGRES_ENTITY_TYPES.trigger ||
+    entity.type === POSTGRES_ENTITY_TYPES.policy
+  ) {
     const signature = canonicalPgObject(entity.type, entity.props, defaultSchema).signature;
     return { schema, name, ...(signature !== undefined ? { signature } : {}) };
   }
@@ -70,10 +78,11 @@ export function scopeFor(target: PostgresTarget, entities: ReadonlyArray<{ type:
   if (target.schemas) return target.schemas;
   if (entities.length === 0) return undefined;
   const out = new Set<string>([target.defaultSchema]);
+  // The schema alone: the rest of an address (a routine's parameter types) needs props a caller may not have.
+  const unplaced = new Set<string>([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, POSTGRES_ENTITY_TYPES.eventTrigger]);
   for (const e of entities) {
-    const a = declaredAddress(e, target.defaultSchema);
-    if (e.type === POSTGRES_ENTITY_TYPES.schema) out.add(a.name);
-    else if (a.schema) out.add(a.schema);
+    if (e.type === POSTGRES_ENTITY_TYPES.schema) out.add(String(e.props.name ?? ""));
+    else if (!unplaced.has(e.type)) out.add(typeof e.props.schema === "string" ? e.props.schema : identValue(target.defaultSchema));
   }
   return [...out].sort();
 }