@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/postgres/entity-types.ts

@@ -18,6 +18,16 @@ export const POSTGRES_ENTITY_TYPES = {
   collation: "Postgres::Collation",
   cast: "Postgres::Cast",
   eventTrigger: "Postgres::EventTrigger",
+  operator: "Postgres::Operator",
+  operatorClass: "Postgres::OperatorClass",
+  operatorFamily: "Postgres::OperatorFamily",
+  foreignTable: "Postgres::ForeignTable",
+  textSearchConfiguration: "Postgres::TextSearchConfiguration",
+  textSearchDictionary: "Postgres::TextSearchDictionary",
+  statistics: "Postgres::Statistics",
+  foreignDataWrapper: "Postgres::ForeignDataWrapper",
+  foreignServer: "Postgres::ForeignServer",
+  publication: "Postgres::Publication",
   extension: "Postgres::Extension",
   function: "Postgres::Function",
   procedure: "Postgres::Procedure",

package/src/postgres/import/generator.ts

@@ -60,6 +60,16 @@ const TAG: Record<string, string> = {
   [POSTGRES_ENTITY_TYPES.collation]: "collation",
   [POSTGRES_ENTITY_TYPES.cast]: "cast",
   [POSTGRES_ENTITY_TYPES.eventTrigger]: "eventTrigger",
+  [POSTGRES_ENTITY_TYPES.operator]: "operator",
+  [POSTGRES_ENTITY_TYPES.operatorClass]: "operatorClass",
+  [POSTGRES_ENTITY_TYPES.operatorFamily]: "operatorFamily",
+  [POSTGRES_ENTITY_TYPES.foreignTable]: "foreignTable",
+  [POSTGRES_ENTITY_TYPES.textSearchConfiguration]: "textSearchConfiguration",
+  [POSTGRES_ENTITY_TYPES.textSearchDictionary]: "textSearchDictionary",
+  [POSTGRES_ENTITY_TYPES.statistics]: "statistics",
+  [POSTGRES_ENTITY_TYPES.foreignDataWrapper]: "foreignDataWrapper",
+  [POSTGRES_ENTITY_TYPES.foreignServer]: "foreignServer",
+  [POSTGRES_ENTITY_TYPES.publication]: "publication",
   [POSTGRES_ENTITY_TYPES.extension]: "extension",
   [POSTGRES_ENTITY_TYPES.function]: "func",
   [POSTGRES_ENTITY_TYPES.procedure]: "procedure",
@@ -81,6 +91,12 @@ const UNREFERENCED: ReadonlySet<string> = new Set([
   POSTGRES_ENTITY_TYPES.extension,
   POSTGRES_ENTITY_TYPES.cast,
   POSTGRES_ENTITY_TYPES.eventTrigger,
+  POSTGRES_ENTITY_TYPES.operator,
+  // An index names a class, but a class and its own family share a name; a configuration shares one with a dictionary, which a mapping names.
+  POSTGRES_ENTITY_TYPES.operatorClass,
+  POSTGRES_ENTITY_TYPES.textSearchConfiguration,
+  POSTGRES_ENTITY_TYPES.statistics,
+  POSTGRES_ENTITY_TYPES.publication,
 ]);
 
 /** The tag each entity type is declared with (`table`, `func`, ...). */
@@ -131,6 +147,17 @@ function bareSpots(tokens: Token[]): Set<number> {
       name(node.function);
     }
     if (node.statement === "eventTrigger") name(node.function);
+    if (node.statement === "foreignServer") name(node.wrapper);
+    if (node.statement === "foreignTable") {
+      for (const c of node.columns) if (c.type) first(c.type.from, c.type.to);
+      name(node.server);
+    }
+    if (node.statement === "operatorClass") first(node.type.from, node.type.to);
+    if (node.statement === "foreignDataWrapper") {
+      name(node.handler ?? undefined);
+      name(node.validator ?? undefined);
+    }
+    if (node.statement === "statistics") name(node.table);
     if (node.statement === "index" || node.statement === "policy") name(node.table);
     if (node.statement === "trigger") {
       name(node.table);
@@ -141,6 +168,25 @@ function bareSpots(tokens: Token[]): Set<number> {
   return out;
 }
 
+/** The tokens that name a schema in a publication's `TABLES IN SCHEMA a, b`, past the first, which follows the word SCHEMA. */
+function schemaSpots(tokens: Token[]): Set<number> {
+  const out = new Set<number>();
+  let nodes: StatementNode[];
+  try {
+    nodes = parseStatements(tokens);
+  } catch {
+    return out;
+  }
+  for (const node of nodes) {
+    if (node.statement !== "publication") continue;
+    for (const i of node.items) {
+      if (i.kind !== "schema") continue;
+      for (let k = i.schema.span.from; k < i.schema.span.to; k++) if (!isTrivia(tokens[k]!)) { out.add(k); break; }
+    }
+  }
+  return out;
+}
+
 function templateBody(item: Item, byQualified: Map<string, Item>, schemaExport: Map<string, string>): TemplateBody {
   const tokens = tokenizeText(item.ddl, 0);
   const sig: number[] = [];
@@ -148,6 +194,7 @@ function templateBody(item: Item, byQualified: Map<string, Item>, schemaExport:
     if (!isTrivia(t)) sig.push(i);
   });
   const spots = bareSpots(tokens);
+  const schemaAt = item.type === POSTGRES_ENTITY_TYPES.publication ? schemaSpots(tokens) : new Set<number>();
   const replace = new Map<number, { to: number; ref: string }>();
   const isSelf = (target: Item) => target === item || (target.exportName === item.exportName && target.type === item.type);
   for (let k = 0; k < sig.length; k++) {
@@ -169,10 +216,15 @@ function templateBody(item: Item, byQualified: Map<string, Item>, schemaExport:
     }
     const dot = tokens[sig[k + 1] ?? -1];
     const b = tokens[sig[k + 2] ?? -1];
+    // An operator's own `schema.symbol`: the schema is the schema's export, though the symbol is no name.
+    if (item.type === POSTGRES_ENTITY_TYPES.operator && isName(a) && dot?.kind === "punct" && dot.text === "." && b?.kind === "op" && identValue(a) === item.schema && schemaExport.has(item.schema)) {
+      replace.set(sig[k]!, { to: sig[k]! + 1, ref: schemaExport.get(item.schema)! });
+      continue;
+    }
     if (!isName(a) || dot?.kind !== "punct" || dot.text !== "." || !isName(b)) {
       // An extension's `WITH SCHEMA app`, a grant's `ON SCHEMA app`, default privileges' `IN SCHEMA app`.
-      const bySchemaWord = item.type === POSTGRES_ENTITY_TYPES.extension || item.type === POSTGRES_ENTITY_TYPES.grant || item.type === POSTGRES_ENTITY_TYPES.defaultPrivileges;
-      if (bySchemaWord && isName(a) && prev?.kind === "ident" && prev.text.toUpperCase() === "SCHEMA") {
+      const bySchemaWord = item.type === POSTGRES_ENTITY_TYPES.extension || item.type === POSTGRES_ENTITY_TYPES.grant || item.type === POSTGRES_ENTITY_TYPES.defaultPrivileges || schemaAt.size > 0;
+      if (bySchemaWord && isName(a) && ((prev?.kind === "ident" && prev.text.toUpperCase() === "SCHEMA") || schemaAt.has(sig[k]!))) {
         const s = schemaExport.get(identValue(a));
         if (s) replace.set(sig[k]!, { to: sig[k]! + 1, ref: s });
         continue;

package/src/postgres/import/live-export.ts

@@ -84,6 +84,7 @@ export async function exportResources(options: ExportOptions): Promise<ExportedT
       warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name} is kept by ${o.foreign}; left out, since declaring it would have chant change what that tool owns`);
       continue;
     }
+    for (const w of o.warnings ?? []) warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name}: ${w}`);
     objects.push({ type: o.type, ...(o.schema ? { schema: o.schema } : {}), name: o.name, ddl: o.statement });
   }
   return objectsToIR([...objects, ...access], warnings) as ExportedTemplate;

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

@@ -23,6 +23,7 @@ import { notExtensionOwned, scopeSql, type LivePgObject, type SchemaScope } from
 import { POSTGRES_ENTITY_TYPES } from "../entity-types";
 import { quoteIdent } from "../keywords";
 import { stripMarker } from "../../core/ownership";
+import { isSecretOption } from "../secret-options";
 
 type Row = Record<string, unknown>;
 
@@ -310,3 +311,496 @@ export async function readRoutineKinds(client: PostgresClient, scope: SchemaScop
   }
   return out;
 }
+
+/** An operator named by another's COMMUTATOR or NEGATOR, as `OPERATOR(schema.symbol)`. */
+const operatorRef = (column: string): string =>
+  `(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: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const s = scopeSql("n.nspname", scope);
+  const rows = await client.query<Row>(
+    `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: unknown): { clause: string; omitted: string[] } {
+  const kept: string[] = [];
+  const omitted: string[] = [];
+  for (const entry of (raw as string[] | null) ?? []) {
+    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: readonly string[]): { warnings?: string[] } =>
+  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: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const out: LivePgObject[] = [...(await readOperators(client, scope))];
+
+  const s = scopeSql("n.nspname", scope);
+  const stats = await client.query<Row>(
+    `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<Row>(
+    `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<Row>(
+    `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: PostgresClient): Promise<LivePgObject[]> {
+  const has = async (catalog: string, column?: string): Promise<boolean> => {
+    const rows = await client.query<Row>(
+      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<Row>(
+    `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: LivePgObject[] = [];
+  for (const r of pubs) {
+    const name = quoteIdent(String(r.name));
+    const d = (typeof r.def === "string" ? JSON.parse(r.def) : r.def) as Record<string, unknown>;
+    const tables = r.alltables
+      ? []
+      : await client.query<Row>(
+          `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<Row>(
+            `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 as string[] | null) ?? [];
+        return `${qname(String(t.schema), String(t.name))}${columns.length > 0 ? ` (${columns.join(", ")})` : ""}${str(t.filter) ? ` WHERE (${t.filter})` : ""}`;
+      }),
+    ];
+    const clauses: string[] = [];
+    if (r.alltables) clauses.push("FOR ALL TABLES");
+    else if (members.length > 0 || schemas.length > 0) {
+      const parts: string[] = [];
+      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: string[] = [];
+    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: string, name: string): string =>
+  `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: string): string => `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: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const out: LivePgObject[] = [];
+  const s = scopeSql("n.nspname", scope);
+  const member = (catalog: string, alias: string) =>
+    `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<Row>(
+    `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 as string[] | null) ?? []), ...((r.functions as string[] | null) ?? []), ...(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<Row>(
+    `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: string | undefined): Array<[string, string]> | undefined {
+  if (init === undefined || init.trim() === "") return [];
+  const out: Array<[string, string]> = [];
+  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: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const out: LivePgObject[] = [];
+  const s = scopeSql("n.nspname", scope);
+  const dictionaries = await client.query<Row>(
+    `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<Row>(
+    `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<string, string[]>();
+    for (const line of (r.mappings as string[] | null) ?? []) {
+      const [token, dictionaries] = line.split("\t") as [string, string];
+      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: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]> {
+  const s = scopeSql("n.nspname", scope);
+  const tables = await client.query<Row>(
+    `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<Row>(
+    `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<Row>(
+    `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): LivePgObject => {
+    const rel = String(t.oid);
+    const q = qname(String(t.schema), String(t.name));
+    const omitted: string[] = [];
+    const lines: string[] = [];
+    const commentLines: string[] = [];
+    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/src/postgres/live/catalog.ts

@@ -53,7 +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";
+import { readCollations, readDatabaseKinds, 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"];
@@ -83,6 +83,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. */
@@ -629,6 +631,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)));
 
+  // 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<Row>(