@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/live/catalog-kinds.js

@@ -21,6 +21,7 @@ import { notExtensionOwned, scopeSql } from "./catalog.js";
 import { POSTGRES_ENTITY_TYPES } from "../entity-types.js";
 import { quoteIdent } from "../keywords.js";
 import { stripMarker } from "../../core/ownership.js";
+import { isSecretOption } from "../secret-options.js";
 const C = 'COLLATE "C"';
 const str = (v) => (v === null || v === undefined ? undefined : String(v));
 const literal = (s) => `'${s.replace(/'/g, "''")}'`;
@@ -299,3 +300,454 @@ export async function readRoutineKinds(client, scope) {
     }
     return out;
 }
+/** An operator named by another's COMMUTATOR or NEGATOR, as `OPERATOR(schema.symbol)`. */
+const operatorRef = (column) => `(SELECT 'OPERATOR(' || pg_catalog.quote_ident(rn.nspname) || '.' || r.oprname || ')' FROM pg_catalog.pg_operator r JOIN pg_catalog.pg_namespace rn ON rn.oid = r.oprnamespace WHERE r.oid = ${column})`;
+/**
+ * Operators: the ones a schema defines, not the server's own (oids below the
+ * first normal object id) or an extension's. Identified by name and operand
+ * types, `NONE` for a missing side (`DROP OPERATOR`'s spelling).
+ */
+export async function readOperators(client, scope) {
+    const s = scopeSql("n.nspname", scope);
+    const rows = await client.query(`SELECT o.oid::text AS oid, n.nspname AS schema, o.oprname AS name,
+            CASE WHEN o.oprleft <> 0 THEN pg_catalog.format_type(o.oprleft, NULL) END AS leftarg,
+            CASE WHEN o.oprright <> 0 THEN pg_catalog.format_type(o.oprright, NULL) END AS rightarg,
+            ${proc("o.oprcode::pg_catalog.regproc")} AS func, ${operatorRef("o.oprcom")} AS commutator, ${operatorRef("o.oprnegate")} AS negator,
+            ${proc("o.oprrest::pg_catalog.regproc")} AS restrict, ${proc("o.oprjoin::pg_catalog.regproc")} AS join_func,
+            o.oprcanhash AS hashes, o.oprcanmerge AS merges,
+            pg_catalog.obj_description(o.oid, 'pg_operator') AS comment, ${dependentsOf("pg_operator", "o.oid")} AS dependents
+     FROM pg_catalog.pg_operator o JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace
+     WHERE ${s.sql} AND o.oid >= 16384 AND ${notExtensionOwned("pg_operator", "o.oid")}
+     ORDER BY n.nspname ${C}, o.oprname ${C}, pg_catalog.format_type(o.oprleft, NULL) ${C} NULLS FIRST, pg_catalog.format_type(o.oprright, NULL) ${C} NULLS FIRST`, s.params);
+    return rows.map((r) => {
+        const left = str(r.leftarg);
+        const right = str(r.rightarg);
+        const signature = `(${left ?? "NONE"},${right ?? "NONE"})`;
+        const name = `${quoteIdent(String(r.schema))}.${r.name}`;
+        const opts = [`FUNCTION = ${r.func}`];
+        if (left)
+            opts.push(`LEFTARG = ${left}`);
+        if (right)
+            opts.push(`RIGHTARG = ${right}`);
+        if (str(r.commutator))
+            opts.push(`COMMUTATOR = ${r.commutator}`);
+        if (str(r.negator))
+            opts.push(`NEGATOR = ${r.negator}`);
+        if (str(r.restrict))
+            opts.push(`RESTRICT = ${r.restrict}`);
+        if (str(r.join_func))
+            opts.push(`JOIN = ${r.join_func}`);
+        if (r.hashes === true)
+            opts.push("HASHES");
+        if (r.merges === true)
+            opts.push("MERGES");
+        return {
+            type: POSTGRES_ENTITY_TYPES.operator,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature,
+            ...withComment(r),
+            ...dependents(r),
+            statement: [`CREATE OPERATOR ${name} (${opts.join(", ")})`, ...commentOn(`OPERATOR ${name}${signature}`, r.comment)].join(";\n"),
+        };
+    });
+}
+/** An `OPTIONS (...)` clause from a catalog `text[]` of `name=value`, and the names left out because they hold a credential. */
+function optionsOf(raw) {
+    const kept = [];
+    const omitted = [];
+    for (const entry of raw ?? []) {
+        const at = entry.indexOf("=");
+        const name = at < 0 ? entry : entry.slice(0, at);
+        if (isSecretOption(name))
+            omitted.push(name);
+        else
+            kept.push(`${quoteIdent(name)} ${literal(at < 0 ? "" : entry.slice(at + 1))}`);
+    }
+    return { clause: kept.length > 0 ? ` OPTIONS (${kept.join(", ")})` : "", omitted };
+}
+const omittedWarning = (omitted) => omitted.length > 0 ? { warnings: [`the option${omitted.length === 1 ? "" : "s"} ${omitted.join(", ")} hold${omitted.length === 1 ? "s" : ""} a credential and ${omitted.length === 1 ? "is" : "are"} left out; the environment supplies it`] } : {};
+/**
+ * The kinds of object #3911 adds that belong to the database or hang off a
+ * table: extended statistics (printed by the server), foreign data wrappers
+ * and servers, and publications, each assembled from its catalog rows. A
+ * wrapper, server or publication is the database's, so the schema scope does
+ * not narrow it. A credential in an option is left out and said so.
+ */
+export async function readDatabaseKinds(client, scope) {
+    const out = [...(await readOperators(client, scope))];
+    const s = scopeSql("n.nspname", scope);
+    const stats = await client.query(`SELECT e.oid::text AS oid, n.nspname AS schema, e.stxname AS name, pg_catalog.pg_get_statisticsobjdef(e.oid) AS def,
+            pg_catalog.obj_description(e.oid, 'pg_statistic_ext') AS comment
+     FROM pg_catalog.pg_statistic_ext e JOIN pg_catalog.pg_namespace n ON n.oid = e.stxnamespace
+     WHERE ${s.sql} AND ${notExtensionOwned("pg_statistic_ext", "e.oid")}
+     ORDER BY n.nspname ${C}, e.stxname ${C}`, s.params);
+    for (const r of stats) {
+        const q = qname(String(r.schema), String(r.name));
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.statistics,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            statement: [String(r.def), ...commentOn(`STATISTICS ${q}`, r.comment)].join(";\n"),
+        });
+    }
+    const wrappers = await client.query(`SELECT w.oid::text AS oid, w.fdwname AS name, ${proc("w.fdwhandler::pg_catalog.regproc")} AS handler, ${proc("w.fdwvalidator::pg_catalog.regproc")} AS validator,
+            w.fdwoptions AS options, pg_catalog.obj_description(w.oid, 'pg_foreign_data_wrapper') AS comment, ${dependentsOf("pg_foreign_data_wrapper", "w.oid")} AS dependents
+     FROM pg_catalog.pg_foreign_data_wrapper w
+     WHERE ${notExtensionOwned("pg_foreign_data_wrapper", "w.oid")}
+     ORDER BY w.fdwname ${C}`);
+    for (const r of wrappers) {
+        const name = quoteIdent(String(r.name));
+        const { clause, omitted } = optionsOf(r.options);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.foreignDataWrapper,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...omittedWarning(omitted),
+            statement: [
+                `CREATE FOREIGN DATA WRAPPER ${name}${str(r.handler) ? ` HANDLER ${r.handler}` : ""}${str(r.validator) ? ` VALIDATOR ${r.validator}` : ""}${clause}`,
+                ...commentOn(`FOREIGN DATA WRAPPER ${name}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const servers = await client.query(`SELECT v.oid::text AS oid, v.srvname AS name, v.srvtype AS type, v.srvversion AS version, w.fdwname AS wrapper, v.srvoptions AS options,
+            pg_catalog.obj_description(v.oid, 'pg_foreign_server') AS comment, ${dependentsOf("pg_foreign_server", "v.oid")} AS dependents
+     FROM pg_catalog.pg_foreign_server v JOIN pg_catalog.pg_foreign_data_wrapper w ON w.oid = v.srvfdw
+     WHERE ${notExtensionOwned("pg_foreign_server", "v.oid")}
+     ORDER BY v.srvname ${C}`);
+    for (const r of servers) {
+        const name = quoteIdent(String(r.name));
+        const { clause, omitted } = optionsOf(r.options);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.foreignServer,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...omittedWarning(omitted),
+            statement: [
+                `CREATE SERVER ${name}${str(r.type) ? ` TYPE ${literal(String(r.type))}` : ""}${str(r.version) ? ` VERSION ${literal(String(r.version))}` : ""} FOREIGN DATA WRAPPER ${quoteIdent(String(r.wrapper))}${clause}`,
+                ...commentOn(`SERVER ${name}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    out.push(...(await readPublications(client)));
+    out.push(...(await readOperatorClasses(client, scope)), ...(await readTextSearch(client, scope)), ...(await readForeignTables(client, scope)));
+    return out;
+}
+/** Publications. Column lists, row filters and schema members are 15's; they are read where the catalog has them. */
+async function readPublications(client) {
+    const has = async (catalog, column) => {
+        const rows = await client.query(column
+            ? `SELECT 1 AS x FROM pg_catalog.pg_attribute WHERE attrelid = to_regclass('pg_catalog.${catalog}') AND attname = '${column}' AND NOT attisdropped`
+            : `SELECT 1 AS x WHERE to_regclass('pg_catalog.${catalog}') IS NOT NULL`);
+        return rows.length > 0;
+    };
+    const columnLists = await has("pg_publication_rel", "prattrs");
+    const schemaMembers = await has("pg_publication_namespace");
+    const pubs = await client.query(`SELECT p.oid::text AS oid, p.pubname AS name, p.puballtables AS alltables, p.pubinsert, p.pubupdate, p.pubdelete, p.pubtruncate,
+            pg_catalog.to_jsonb(p) AS def, pg_catalog.obj_description(p.oid, 'pg_publication') AS comment
+     FROM pg_catalog.pg_publication p
+     WHERE ${notExtensionOwned("pg_publication", "p.oid")}
+     ORDER BY p.pubname ${C}`);
+    const out = [];
+    for (const r of pubs) {
+        const name = quoteIdent(String(r.name));
+        const d = (typeof r.def === "string" ? JSON.parse(r.def) : r.def);
+        const tables = r.alltables
+            ? []
+            : await client.query(`SELECT n.nspname AS schema, c.relname AS name,
+                  ${columnLists ? "ARRAY(SELECT pg_catalog.quote_ident(a.attname) FROM pg_catalog.pg_attribute a WHERE a.attrelid = r.prrelid AND a.attnum = ANY(r.prattrs::pg_catalog.int2[]) ORDER BY a.attnum)" : "NULL::text[]"} AS columns,
+                  ${columnLists ? "pg_catalog.pg_get_expr(r.prqual, r.prrelid)" : "NULL::text"} AS filter
+           FROM pg_catalog.pg_publication_rel r JOIN pg_catalog.pg_class c ON c.oid = r.prrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+           WHERE r.prpubid = $1::oid ORDER BY n.nspname ${C}, c.relname ${C}`, [String(r.oid)]);
+        const schemas = schemaMembers && !r.alltables
+            ? await client.query(`SELECT n.nspname AS name FROM pg_catalog.pg_publication_namespace pn JOIN pg_catalog.pg_namespace n ON n.oid = pn.pnnspid WHERE pn.pnpubid = $1::oid ORDER BY n.nspname ${C}`, [String(r.oid)])
+            : [];
+        const members = [
+            ...tables.map((t) => {
+                const columns = t.columns ?? [];
+                return `${qname(String(t.schema), String(t.name))}${columns.length > 0 ? ` (${columns.join(", ")})` : ""}${str(t.filter) ? ` WHERE (${t.filter})` : ""}`;
+            }),
+        ];
+        const clauses = [];
+        if (r.alltables)
+            clauses.push("FOR ALL TABLES");
+        else if (members.length > 0 || schemas.length > 0) {
+            const parts = [];
+            if (members.length > 0)
+                parts.push(`TABLE ${members.join(", ")}`);
+            if (schemas.length > 0)
+                parts.push(`TABLES IN SCHEMA ${schemas.map((x) => quoteIdent(String(x.name))).join(", ")}`);
+            clauses.push(`FOR ${parts.join(", ")}`);
+        }
+        const publish = [r.pubinsert && "insert", r.pubupdate && "update", r.pubdelete && "delete", r.pubtruncate && "truncate"].filter(Boolean);
+        const options = [];
+        if (publish.length !== 4)
+            options.push(`publish = ${literal(publish.join(", "))}`);
+        if (d.pubviaroot === true)
+            options.push("publish_via_partition_root = true");
+        if (d.pubgencols !== undefined && d.pubgencols !== "n")
+            options.push("publish_generated_columns = stored");
+        if (options.length > 0)
+            clauses.push(`WITH (${options.join(", ")})`);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.publication,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            statement: [`CREATE PUBLICATION ${name}${clauses.length > 0 ? ` ${clauses.join(" ")}` : ""}`, ...commentOn(`PUBLICATION ${name}`, r.comment)].join(";\n"),
+        });
+    }
+    return out;
+}
+// ── Operator classes and families, text search, foreign tables (#4406) ──
+/** An object named by `schema`.`name` columns, as a clause: a `pg_catalog` one bare. */
+const refName = (schema, name) => `CASE WHEN ${schema} = 'pg_catalog' THEN pg_catalog.quote_ident(${name}) ELSE pg_catalog.quote_ident(${schema}) || '.' || pg_catalog.quote_ident(${name}) END`;
+/** An operand type, `NONE` for the missing side of a prefix operator. */
+const operand = (column) => `CASE WHEN ${column} = 0 THEN 'NONE' ELSE pg_catalog.format_type(${column}, NULL) END`;
+/**
+ * Operator classes and families. A class carries its members: the operators
+ * and support functions that depend on it (`pg_depend`, a member made by
+ * CREATE OPERATOR CLASS depends on the class; one added by ALTER OPERATOR
+ * FAMILY ... ADD depends on the family and is "loose"). A family named as its
+ * class, in the same schema, is the one CREATE OPERATOR CLASS made for it and
+ * is the class's; every other family is read, with a warning when it holds
+ * loose members, which a declaration cannot carry.
+ */
+async function readOperatorClasses(client, scope) {
+    const out = [];
+    const s = scopeSql("n.nspname", scope);
+    const member = (catalog, alias) => `JOIN pg_catalog.pg_depend dep ON dep.classid = '${catalog}'::pg_catalog.regclass AND dep.objid = ${alias}.oid AND dep.refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass AND dep.refobjid = c.oid`;
+    const classes = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.opcname AS name, am.amname AS method, c.opcdefault AS isdefault,
+            pg_catalog.format_type(c.opcintype, NULL) AS type,
+            CASE WHEN c.opckeytype <> 0 THEN pg_catalog.format_type(c.opckeytype, NULL) END AS storage,
+            CASE WHEN f.opfname = c.opcname AND f.opfnamespace = c.opcnamespace THEN NULL ELSE ${refName("fn.nspname", "f.opfname")} END AS family,
+            ARRAY(SELECT 'OPERATOR ' || o.amopstrategy || ' ' || pg_catalog.quote_ident(opn.nspname) || '.' || op.oprname ||
+                         ' (' || ${operand("o.amoplefttype")} || ', ' || ${operand("o.amoprighttype")} || ')' ||
+                         CASE WHEN o.amoppurpose = 'o' THEN ' FOR ORDER BY ' || (SELECT pg_catalog.quote_ident(sn.nspname) || '.' || pg_catalog.quote_ident(sf.opfname)
+                              FROM pg_catalog.pg_opfamily sf JOIN pg_catalog.pg_namespace sn ON sn.oid = sf.opfnamespace WHERE sf.oid = o.amopsortfamily) ELSE '' END
+                  FROM pg_catalog.pg_amop o ${member("pg_catalog.pg_amop", "o")}
+                  JOIN pg_catalog.pg_operator op ON op.oid = o.amopopr JOIN pg_catalog.pg_namespace opn ON opn.oid = op.oprnamespace
+                  ORDER BY o.amopstrategy, o.amoplefttype, o.amoprighttype) AS operators,
+            ARRAY(SELECT 'FUNCTION ' || p.amprocnum || ' (' || ${operand("p.amproclefttype")} || ', ' || ${operand("p.amprocrighttype")} || ') ' || p.amproc::pg_catalog.regprocedure::pg_catalog.text
+                  FROM pg_catalog.pg_amproc p ${member("pg_catalog.pg_amproc", "p")}
+                  ORDER BY p.amprocnum, p.amproclefttype, p.amprocrighttype) AS functions,
+            pg_catalog.obj_description(c.oid, 'pg_opclass') AS comment, ${dependentsOf("pg_opclass", "c.oid")} AS dependents
+     FROM pg_catalog.pg_opclass c JOIN pg_catalog.pg_namespace n ON n.oid = c.opcnamespace JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod
+     JOIN pg_catalog.pg_opfamily f ON f.oid = c.opcfamily JOIN pg_catalog.pg_namespace fn ON fn.oid = f.opfnamespace
+     WHERE ${s.sql} AND c.oid >= 16384 AND ${notExtensionOwned("pg_opclass", "c.oid")}
+     ORDER BY n.nspname ${C}, c.opcname ${C}, am.amname ${C}`, s.params);
+    for (const r of classes) {
+        const q = qname(String(r.schema), String(r.name));
+        const method = String(r.method);
+        const items = [...(r.operators ?? []), ...(r.functions ?? []), ...(str(r.storage) ? [`STORAGE ${r.storage}`] : [])];
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.operatorClass,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature: ` USING ${method}`,
+            ...withComment(r),
+            ...dependents(r),
+            ...(items.length === 0 ? { unsupported: "no operator, support function or storage type of it could be read; a CREATE OPERATOR CLASS needs at least one" } : {}),
+            statement: [
+                `CREATE OPERATOR CLASS ${q}${r.isdefault === true ? " DEFAULT" : ""} FOR TYPE ${r.type} USING ${method}${str(r.family) ? ` FAMILY ${r.family}` : ""} AS\n    ${items.join(",\n    ")}`,
+                ...commentOn(`OPERATOR CLASS ${q} USING ${method}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const families = await client.query(`SELECT f.oid::text AS oid, n.nspname AS schema, f.opfname AS name, am.amname AS method,
+            (SELECT count(*) FROM (SELECT o.oid FROM pg_catalog.pg_amop o WHERE o.amopfamily = f.oid UNION ALL SELECT p.oid FROM pg_catalog.pg_amproc p WHERE p.amprocfamily = f.oid) m
+              WHERE NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend dep WHERE dep.classid IN ('pg_catalog.pg_amop'::pg_catalog.regclass, 'pg_catalog.pg_amproc'::pg_catalog.regclass)
+                                AND dep.objid = m.oid AND dep.refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass)) AS loose,
+            pg_catalog.obj_description(f.oid, 'pg_opfamily') AS comment, ${dependentsOf("pg_opfamily", "f.oid")} AS dependents
+     FROM pg_catalog.pg_opfamily f JOIN pg_catalog.pg_namespace n ON n.oid = f.opfnamespace JOIN pg_catalog.pg_am am ON am.oid = f.opfmethod
+     WHERE ${s.sql} AND f.oid >= 16384 AND ${notExtensionOwned("pg_opfamily", "f.oid")}
+       AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_opclass c WHERE c.opcfamily = f.oid AND c.opcname = f.opfname AND c.opcnamespace = f.opfnamespace)
+     ORDER BY n.nspname ${C}, f.opfname ${C}, am.amname ${C}`, s.params);
+    for (const r of families) {
+        const q = qname(String(r.schema), String(r.name));
+        const method = String(r.method);
+        const loose = Number(r.loose ?? 0);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.operatorFamily,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature: ` USING ${method}`,
+            ...withComment(r),
+            ...dependents(r),
+            ...(loose > 0 ? { warnings: [`${loose} loose member${loose === 1 ? "" : "s"} added with ALTER OPERATOR FAMILY ... ADD ${loose === 1 ? "is" : "are"} left out; a declaration holds the family and its classes' members`] } : {}),
+            statement: [`CREATE OPERATOR FAMILY ${q} USING ${method}`, ...commentOn(`OPERATOR FAMILY ${q} USING ${method}`, r.comment)].join(";\n"),
+        });
+    }
+    return out;
+}
+/**
+ * A dictionary's `dictinitoption`, which the server prints as
+ * `name = 'value', ...` (a quote and a backslash doubled in the value), as a
+ * list of name and value; undefined when the text is not that form.
+ */
+export function parseDictionaryOptions(init) {
+    if (init === undefined || init.trim() === "")
+        return [];
+    const out = [];
+    const item = /\s*("(?:[^"]|"")+"|[^\s=,]+)\s*=\s*'((?:[^']|'')*)'\s*(?:,|$)/y;
+    let at = 0;
+    while (at < init.length) {
+        item.lastIndex = at;
+        const m = item.exec(init);
+        if (!m)
+            return undefined;
+        const name = m[1].startsWith('"') ? m[1].slice(1, -1).replace(/""/g, '"') : m[1];
+        out.push([name, m[2].replace(/''/g, "'").replace(/\\\\/g, "\\")]);
+        at = item.lastIndex;
+    }
+    return out;
+}
+/** Text search dictionaries and configurations; a configuration's mappings are the ALTER ... ADD MAPPING statements after its CREATE. */
+async function readTextSearch(client, scope) {
+    const out = [];
+    const s = scopeSql("n.nspname", scope);
+    const dictionaries = await client.query(`SELECT d.oid::text AS oid, n.nspname AS schema, d.dictname AS name, d.dictinitoption AS init,
+            (SELECT ${refName("tn.nspname", "t.tmplname")} FROM pg_catalog.pg_ts_template t JOIN pg_catalog.pg_namespace tn ON tn.oid = t.tmplnamespace WHERE t.oid = d.dicttemplate) AS template,
+            pg_catalog.obj_description(d.oid, 'pg_ts_dict') AS comment, ${dependentsOf("pg_ts_dict", "d.oid")} AS dependents
+     FROM pg_catalog.pg_ts_dict d JOIN pg_catalog.pg_namespace n ON n.oid = d.dictnamespace
+     WHERE ${s.sql} AND d.oid >= 16384 AND ${notExtensionOwned("pg_ts_dict", "d.oid")}
+     ORDER BY n.nspname ${C}, d.dictname ${C}`, s.params);
+    for (const r of dictionaries) {
+        const q = qname(String(r.schema), String(r.name));
+        const options = parseDictionaryOptions(str(r.init));
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.textSearchDictionary,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...(options === undefined ? { unsupported: `its options (${str(r.init)}) are not in the form the server writes them` } : {}),
+            statement: [
+                `CREATE TEXT SEARCH DICTIONARY ${q} (${["TEMPLATE = " + r.template, ...(options ?? []).map(([k, v]) => `${quoteIdent(k)} = ${literal(v)}`)].join(", ")})`,
+                ...commentOn(`TEXT SEARCH DICTIONARY ${q}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const configurations = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.cfgname AS name,
+            (SELECT ${refName("pn.nspname", "p.prsname")} FROM pg_catalog.pg_ts_parser p JOIN pg_catalog.pg_namespace pn ON pn.oid = p.prsnamespace WHERE p.oid = c.cfgparser) AS parser,
+            ARRAY(SELECT tt.alias || E'\\t' || pg_catalog.string_agg((SELECT ${refName("dn.nspname", "d.dictname")} FROM pg_catalog.pg_ts_dict d JOIN pg_catalog.pg_namespace dn ON dn.oid = d.dictnamespace WHERE d.oid = m.mapdict), ', ' ORDER BY m.mapseqno)
+                  FROM pg_catalog.pg_ts_config_map m, pg_catalog.ts_token_type(c.cfgparser) tt WHERE m.mapcfg = c.oid AND tt.tokid = m.maptokentype
+                  GROUP BY tt.tokid, tt.alias ORDER BY tt.tokid) AS mappings,
+            pg_catalog.obj_description(c.oid, 'pg_ts_config') AS comment, ${dependentsOf("pg_ts_config", "c.oid")} AS dependents
+     FROM pg_catalog.pg_ts_config c JOIN pg_catalog.pg_namespace n ON n.oid = c.cfgnamespace
+     WHERE ${s.sql} AND c.oid >= 16384 AND ${notExtensionOwned("pg_ts_config", "c.oid")}
+     ORDER BY n.nspname ${C}, c.cfgname ${C}`, s.params);
+    for (const r of configurations) {
+        const q = qname(String(r.schema), String(r.name));
+        // Token types that share their dictionaries share an ADD MAPPING, in the parser's token order.
+        const groups = new Map();
+        for (const line of r.mappings ?? []) {
+            const [token, dictionaries] = line.split("\t");
+            groups.set(dictionaries, [...(groups.get(dictionaries) ?? []), quoteIdent(token)]);
+        }
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.textSearchConfiguration,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            statement: [
+                `CREATE TEXT SEARCH CONFIGURATION ${q} (PARSER = ${r.parser})`,
+                ...[...groups].map(([dicts, tokens]) => `ALTER TEXT SEARCH CONFIGURATION ${q} ADD MAPPING FOR ${tokens.join(", ")} WITH ${dicts}`),
+                ...commentOn(`TEXT SEARCH CONFIGURATION ${q}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    return out;
+}
+/**
+ * Foreign tables: their columns (type, collation, default, NOT NULL and
+ * OPTIONS), CHECK constraints, server and OPTIONS. One that is a partition,
+ * inherits or has a generated column is read as unsupported, since a
+ * declaration does not hold those. An option that holds a credential is left
+ * out and said so.
+ */
+async function readForeignTables(client, scope) {
+    const s = scopeSql("n.nspname", scope);
+    const tables = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.relname AS name, c.relispartition AS ispartition,
+            EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid) AS inherits,
+            fs.srvname AS server, ft.ftoptions AS options,
+            pg_catalog.obj_description(c.oid, 'pg_class') AS comment, ${dependentsOf("pg_class", "c.oid")} AS dependents
+     FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     JOIN pg_catalog.pg_foreign_table ft ON ft.ftrelid = c.oid JOIN pg_catalog.pg_foreign_server fs ON fs.oid = ft.ftserver
+     WHERE c.relkind = 'f' AND ${s.sql} AND ${notExtensionOwned("pg_class", "c.oid")}
+     ORDER BY n.nspname ${C}, c.relname ${C}`, s.params);
+    if (tables.length === 0)
+        return [];
+    const oids = tables.map((t) => String(t.oid));
+    const columns = await client.query(`SELECT a.attrelid::text AS rel, a.attname AS name, pg_catalog.format_type(a.atttypid, a.atttypmod) AS type, a.attnotnull AS notnull,
+            a.attgenerated::text AS generated, pg_catalog.pg_get_expr(d.adbin, d.adrelid, true) AS dflt,
+            CASE WHEN a.attcollation <> 0 AND a.attcollation <> t.typcollation THEN ${collationName("a.attcollation")} END AS collation,
+            a.attfdwoptions AS options, pg_catalog.col_description(a.attrelid, a.attnum) AS comment
+     FROM pg_catalog.pg_attribute AS a JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+     LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+     WHERE a.attrelid = ANY($1::oid[]) AND a.attnum > 0 AND NOT a.attisdropped
+     ORDER BY a.attrelid, a.attnum`, [oids]);
+    const checks = await client.query(`SELECT k.conrelid::text AS rel, k.conname AS name, pg_catalog.pg_get_constraintdef(k.oid, true) AS def, pg_catalog.obj_description(k.oid, 'pg_constraint') AS comment
+     FROM pg_catalog.pg_constraint k
+     WHERE k.conrelid = ANY($1::oid[]) AND k.contype = 'c' AND k.conislocal
+     ORDER BY k.conrelid, k.conname ${C}`, [oids]);
+    return tables.map((t) => {
+        const rel = String(t.oid);
+        const q = qname(String(t.schema), String(t.name));
+        const omitted = [];
+        const lines = [];
+        const commentLines = [];
+        let generated = false;
+        for (const c of columns.filter((x) => String(x.rel) === rel)) {
+            const parts = [quoteIdent(String(c.name)), String(c.type)];
+            const opts = optionsOf(c.options);
+            omitted.push(...opts.omitted);
+            if (opts.clause)
+                parts.push(opts.clause.trim());
+            if (str(c.collation))
+                parts.push(`COLLATE ${c.collation}`);
+            if (str(c.generated))
+                generated = true;
+            else if (str(c.dflt))
+                parts.push(`DEFAULT ${c.dflt}`);
+            if (c.notnull === true)
+                parts.push("NOT NULL");
+            lines.push(parts.join(" "));
+            commentLines.push(...commentOn(`COLUMN ${q}.${quoteIdent(String(c.name))}`, c.comment));
+        }
+        for (const k of checks.filter((x) => String(x.rel) === rel)) {
+            lines.push(`CONSTRAINT ${quoteIdent(String(k.name))} ${k.def}`);
+            commentLines.push(...commentOn(`CONSTRAINT ${quoteIdent(String(k.name))} ON ${q}`, k.comment));
+        }
+        const { clause, omitted: tableOmitted } = optionsOf(t.options);
+        omitted.push(...tableOmitted);
+        const unsupported = t.ispartition === true ? "it is a partition of another table (CREATE FOREIGN TABLE ... PARTITION OF is not declared)" : t.inherits === true ? "it inherits from another table (INHERITS is not declared on a foreign table)" : generated ? "it has a generated column (not declared on a foreign table)" : undefined;
+        return {
+            type: POSTGRES_ENTITY_TYPES.foreignTable,
+            schema: String(t.schema),
+            name: String(t.name),
+            oid: rel,
+            ...withComment(t),
+            ...dependents(t),
+            ...omittedWarning(omitted),
+            ...(unsupported ? { unsupported } : {}),
+            statement: [
+                `CREATE FOREIGN TABLE ${q} (${lines.length > 0 ? `\n    ${lines.join(",\n    ")}\n` : ""}) SERVER ${quoteIdent(String(t.server))}${clause}`,
+                ...commentOn(`FOREIGN TABLE ${q}`, t.comment),
+                ...commentLines,
+            ].join(";\n"),
+        };
+    });
+}

package/dist/postgres/live/catalog.d.ts

@@ -74,6 +74,8 @@ export interface LivePgObject {
     dependents?: string[];
     /** Why no declaration can hold this object; it is read so import can say it left it out. */
     unsupported?: string;
+    /** What was left out of an object that is otherwise read (an option that holds a credential), for import to say. */
+    warnings?: string[];
 }
 /** What {@link readLiveSchema} reads. */
 export interface SchemaScope {

package/dist/postgres/live/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKjF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAmD,CAAC;AAE/E,gHAAgH;AAChH,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uIAAuI;IACvI,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iIAAiI;IACjI,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,4FAA4F;IAC5F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,gHAAgH;IAChH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2GAA2G;IAC3G,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAqBD,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAM/F;AAED,yGAAyG;AACzG,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,KAAK,MAAM,KAAG,MAC4F,CAAC;AAa9J,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAQD,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,CAKtH;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAa9E;AAcD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA+f7G;AAED,+HAA+H;AAC/H,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,EAAE,YAAY,MAAM,KAAG,MAA6D,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GAAG,YAAY,EAAE,CAW1H"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKjF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAmD,CAAC;AAE/E,gHAAgH;AAChH,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uIAAuI;IACvI,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iIAAiI;IACjI,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,4FAA4F;IAC5F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oHAAoH;IACpH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,gHAAgH;IAChH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2GAA2G;IAC3G,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAqBD,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAM/F;AAED,yGAAyG;AACzG,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,KAAK,MAAM,KAAG,MAC4F,CAAC;AAa9J,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAQD,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,CAKtH;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAa9E;AAcD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAkgB7G;AAED,+HAA+H;AAC/H,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,EAAE,YAAY,MAAM,KAAG,MAA6D,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GAAG,YAAY,EAAE,CAW1H"}

package/dist/postgres/live/catalog.js

@@ -50,7 +50,7 @@ import { hasChantTrailerKey, RECEIPTS_TRAILER_KEY, stripMarker } from "../../cor
 import { MIGRATION_TRAILER_KEY } from "../migrate/names.js";
 import { isProviderOwned, providerData } from "../providers/index.js";
 import { FOREIGN_TABLES } from "../../core/foreign-tables.js";
-import { readCollations, readRoutineKinds, readTypeKinds } from "./catalog-kinds.js";
+import { readCollations, readDatabaseKinds, readRoutineKinds, readTypeKinds } from "./catalog-kinds.js";
 /** The server's own schemas, never part of a declared schema. */
 export const SYSTEM_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast"];
 /** Tables another tool keeps its migration history in, by name, with the tool; both dialects share the list. */
@@ -535,6 +535,8 @@ export async function readLiveSchema(client, scope = {}) {
     }
     // Aggregates, casts and event triggers, after the functions they call (#3911).
     out.push(...(await readRoutineKinds(client, scope)));
+    // Extended statistics, foreign data wrappers and servers, and publications (#3911).
+    out.push(...(await readDatabaseKinds(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(`SELECT t.oid::text AS oid, n.nspname AS schema, c.relname AS table_name, t.tgname AS name, pg_catalog.pg_get_triggerdef(t.oid, true) AS def,

package/dist/postgres/live/describe-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,uBAAuB,EAG7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAoD,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAYjH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EAAE,aAAa,EAAE,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBtK;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQxI;AAED,+HAA+H;AAC/H,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,GAAG,SAAS,CAWhJ;AAqDD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}
+{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,uBAAuB,EAG7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAoD,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAoBjH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EAAE,aAAa,EAAE,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAoBtK;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQxI;AAED,+HAA+H;AAC/H,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,GAAG,SAAS,CAWhJ;AAqDD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}

package/dist/postgres/live/describe-resources.js

@@ -21,6 +21,13 @@ import { POSTGRES_ENTITY_TYPES } from "../entity-types.js";
 import { isChantManaged, readMarker, stripMarker } from "../../core/ownership.js";
 import { identValue } from "../parser.js";
 import { canonicalPgObject } from "../plan/normalize.js";
+/** The entity types that belong to the database, not a schema. */
+const UNPLACED = new Set([
+    POSTGRES_ENTITY_TYPES.eventTrigger,
+    POSTGRES_ENTITY_TYPES.foreignDataWrapper,
+    POSTGRES_ENTITY_TYPES.foreignServer,
+    POSTGRES_ENTITY_TYPES.publication,
+]);
 /**
  * The schema and name a declared entity is created as; a bare name is in the
  * default schema. A routine's parameter types and a trigger's table tell it
@@ -28,7 +35,7 @@ import { canonicalPgObject } from "../plan/normalize.js";
  */
 export function declaredAddress(entity, defaultSchema) {
     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 || entity.type === POSTGRES_ENTITY_TYPES.eventTrigger)
+    if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role || UNPLACED.has(entity.type))
         return { name };
     // A cast is named by its two types, as the catalog prints them.
     if (entity.type === POSTGRES_ENTITY_TYPES.cast)
@@ -37,6 +44,9 @@ export function declaredAddress(entity, defaultSchema) {
     if (entity.type === POSTGRES_ENTITY_TYPES.function ||
         entity.type === POSTGRES_ENTITY_TYPES.procedure ||
         entity.type === POSTGRES_ENTITY_TYPES.aggregate ||
+        entity.type === POSTGRES_ENTITY_TYPES.operator ||
+        entity.type === POSTGRES_ENTITY_TYPES.operatorClass ||
+        entity.type === POSTGRES_ENTITY_TYPES.operatorFamily ||
         entity.type === POSTGRES_ENTITY_TYPES.trigger ||
         entity.type === POSTGRES_ENTITY_TYPES.policy) {
         const signature = canonicalPgObject(entity.type, entity.props, defaultSchema).signature;
@@ -66,7 +76,7 @@ export function scopeFor(target, entities) {
         return undefined;
     const out = new Set([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([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, POSTGRES_ENTITY_TYPES.eventTrigger]);
+    const unplaced = new Set([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, ...UNPLACED]);
     for (const e of entities) {
         if (e.type === POSTGRES_ENTITY_TYPES.schema)
             out.add(String(e.props.name ?? ""));

package/dist/postgres/migrate/backfill.d.ts

@@ -87,6 +87,8 @@ export interface VerifyResult {
     mismatched: number;
     /** Rows whose new column is NULL. */
     nulls: number;
+    /** A rename with a type change: rows whose old column differs from `reverse` over the new one. */
+    unreversed?: number;
     /** The sum of a 64-bit hash of every new value, and of every value the expression gives. */
     checksum: string;
     expected: string;

package/dist/postgres/migrate/backfill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAKH,OAAO,EAA0C,KAAK,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAC9F,OAAO,EAAwC,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAmD,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAE7F,OAAO,EAAiD,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAEtF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+DAA+D;AAC/D,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,KAAG,MAAmC,CAAC;AAE7F,8IAA8I;AAC9I,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,oBAAoB,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG,MAAM,CASrG;AAED,mGAAmG;AACnG,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,+GAA+G;IAC/G,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,4EAA4E;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,2CAA2C;IAC3C,eAAe,CAAC,EAAE,OAAO,eAAe,CAAC;CAC1C;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2DlG;AAID,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrC,8GAA8G;IAC9G,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,uDAAuD;AACvD,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAAC;gBADpD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAAC,EAC7D,MAAM,EAAE,MAAM;CAKjB;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CA0C9E"}
+{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../src/postgres/migrate/backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAKH,OAAO,EAA0C,KAAK,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAC9F,OAAO,EAAwC,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAmD,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAE7F,OAAO,EAAiD,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAEtF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+DAA+D;AAC/D,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,OAAO,MAAM,KAAG,MAAmC,CAAC;AAE7F,8IAA8I;AAC9I,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,oBAAoB,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG,MAAM,CASrG;AAED,mGAAmG;AACnG,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,MAAM,WAAW,YAAY;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,+GAA+G;IAC/G,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,4EAA4E;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,2CAA2C;IAC3C,eAAe,CAAC,EAAE,OAAO,eAAe,CAAC;CAC1C;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2DlG;AAID,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACrC,8GAA8G;IAC9G,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,kGAAkG;IAClG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,uDAAuD;AACvD,qBAAa,0BAA2B,SAAQ,KAAK;IAEjD,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAAC;gBADpD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,YAAY,CAAC,EAC7D,MAAM,EAAE,MAAM;CAKjB;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAoD9E"}

package/dist/postgres/migrate/backfill.js

@@ -142,6 +142,7 @@ export async function verifyMigration(run) {
     const nw = col(n.newColumn);
     const [row] = await inTransaction(run, (exec) => exec(`SELECT count(*)::text AS rows, count(*) FILTER (WHERE ${nw} IS DISTINCT FROM (${o.expression}))::text AS mismatched,
                 count(*) FILTER (WHERE ${nw} IS NULL)::text AS nulls,
+                ${o.reverse !== undefined ? `count(*) FILTER (WHERE (${o.reverse}) IS DISTINCT FROM ${col(n.source)})::text` : "'0'"} AS unreversed,
                 COALESCE(sum(pg_catalog.hashtextextended(${nw}::text, 0)), 0)::text AS checksum,
                 COALESCE(sum(pg_catalog.hashtextextended((${o.expression})::text, 0)), 0)::text AS expected
          FROM ${n.qualifiedTable}`), { scan: true });
@@ -149,6 +150,10 @@ export async function verifyMigration(run) {
     if (r.mismatched > 0 || r.checksum !== r.expected) {
         throw new MigrationVerificationError(n.key, { state: o.state, ...r }, `${r.mismatched} of ${r.rows} row(s) have ${n.newColumn} different from ${o.expression} (checksums ${r.checksum} and ${r.expected})`);
     }
+    const unreversed = Number(row?.unreversed ?? 0);
+    if (o.reverse !== undefined && unreversed > 0) {
+        throw new MigrationVerificationError(n.key, { state: o.state, ...r, unreversed }, `${unreversed} of ${r.rows} row(s) have ${n.source} different from ${o.reverse}, which must give the old value back from the new one (it would write ${n.source} wrongly for a writer of ${n.column})`);
+    }
     if (requiresNotNull(o.column, o.carried) && r.nulls > 0) {
         throw new MigrationVerificationError(n.key, { state: o.state, ...r }, `${r.nulls} of ${r.rows} row(s) have ${n.newColumn} NULL, and ${n.column} is declared NOT NULL or is in the primary key`);
     }
@@ -159,12 +164,13 @@ export async function verifyMigration(run) {
     const carried = o.carried.length > 0 || o.views.length > 0
         ? `; ${o.carried.map((c) => `${c.kind} ${c.name}${c.target !== c.name ? ` (as ${c.target})` : ""}`).join(", ") || "no index or constraint"} carried over${o.views.length > 0 ? `, view(s) ${o.views.map((v) => v.name).join(", ")} made again at the switch` : ""}`
         : "";
-    const summary = `${n.key}: ${r.rows} row(s), ${n.newColumn} equal to ${o.expression} in every one (checksum ${r.checksum})${carried}`;
+    const summary = `${n.key}: ${r.rows} row(s), ${n.newColumn} equal to ${o.expression} in every one (checksum ${r.checksum})${o.reverse !== undefined ? `, ${n.source} equal to ${o.reverse} in every one` : ""}${carried}`;
     run.log(`-- ${summary}`);
     return {
         state: o.state,
         planDigest: computePlanDigest("postgres-migration", { plan: migrationPlanSubject(o), table: o.oid, column: o.newColumn.attnum, verified: { mismatched: 0 } }),
         ...r,
+        ...(o.reverse !== undefined ? { unreversed } : {}),
         summary,
     };
 }