@intentius/chant-lexicon-sql 0.124.48 → 0.124.49

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

@@ -459,6 +459,7 @@ export async function readDatabaseKinds(client: PostgresClient, scope: SchemaSco
   }
 
   out.push(...(await readPublications(client)));
+  out.push(...(await readOperatorClasses(client, scope)), ...(await readTextSearch(client, scope)), ...(await readForeignTables(client, scope)));
   return out;
 }
 
@@ -533,3 +534,273 @@ async function readPublications(client: PostgresClient): Promise<LivePgObject[]>
   }
   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/describe-resources.ts

@@ -58,6 +58,8 @@ export function declaredAddress(entity: { type: string; props: Record<string, un
     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
   ) {

package/src/postgres/migrate/observe.ts

@@ -49,7 +49,7 @@ import { POSTGRES_ENTITY_TYPES } from "../entity-types";
 import type { ColumnDef } from "../entities";
 import type { DeclaredPgObject } from "../apply/statements";
 import { col, migrationNames, MIGRATION_TRAILER_KEY, pgName, type MigrationChange, type MigrationNames } from "./names";
-import { publicationsOf, type PublicationHit } from "./replication";
+import { publicationsOf, subscriptionRefusal, subscriptionsOf, type PublicationHit } from "./replication";
 import { keyText, type KeyColumn } from "./batches";
 import { carriedStates, carriedSubject, columnSequence, discoverDependents, replaceColumn, storedType, type CarriedObject, type CarriedState, type CarriedView, type ColumnSequence, type Dependents } from "./carry";
 
@@ -405,6 +405,8 @@ export async function observeMigration(input: ObserveInput): Promise<MigrationOb
           `A migration of the publisher and the subscriber together is chant #3332.`,
       );
     }
+    const subscriptions = await subscriptionsOf(client, schema, table, major);
+    if (subscriptions.length > 0) throw new MigrationRefusal(subscriptionRefusal(where, input.column, subscriptions));
   }
 
   // After a rename's switch the old column still holds the default or the identity the contract moves, and its sequence is read for it.

package/src/postgres/migrate/replication.ts

@@ -34,6 +34,32 @@
  * publication sends the migrated column of, naming each publication. A
  * publication with a column list (15 and later) that leaves the column out
  * sends neither it nor the new one, and does not stop the migration.
+ *
+ * ## Subscriptions (#4405)
+ *
+ * The other side: a table that is the target of a subscription. The
+ * subscription's apply worker runs with `session_replication_role = replica`
+ * ("Logical Replication", Architecture,
+ * https://www.postgresql.org/docs/18/logical-replication-architecture.html),
+ * and a trigger made by plain `CREATE TRIGGER` is `ENABLE ORIGIN`: it fires
+ * only while the setting is `origin` or `local`
+ * (https://www.postgresql.org/docs/18/runtime-config-client.html#GUC-SESSION-REPLICATION-ROLE).
+ * Only `ENABLE REPLICA` and `ENABLE ALWAYS` triggers fire for the worker
+ * (https://www.postgresql.org/docs/18/sql-altertable.html, the TRIGGER
+ * clauses). The architecture page says "by default, triggers and rules will
+ * not fire on a subscriber" and points to `ENABLE TRIGGER` to change it. So the dual write
+ * never sees a replicated row, and the new column goes stale. The initial
+ * table copy is the exception: it is a `COPY` and fires plain triggers.
+ *
+ * `ENABLE ALWAYS` would make the trigger fire, and the Plan phase refuses
+ * the table instead, because the Op's later steps assume it controls every
+ * writer of the old column. The publisher keeps sending the old column's name
+ * and the subscriber applies by name, so a rename's contract (which drops the
+ * old column) would stop the apply at the next row, and the switch of a
+ * type change would change the column under a running apply worker. Neither
+ * order can be made inside this Op's one connection to one server; that is
+ * the same limit #3332 recorded for the publisher side. The refusal names
+ * each subscription.
  */
 
 import type { PostgresClient } from "../live/client";
@@ -149,3 +175,43 @@ function sleepFor(ms: number, signal?: AbortSignal): Promise<void> {
     );
   });
 }
+
+/** One subscription that has the table, or a partition of it, as a target. */
+export interface SubscriptionHit {
+  name: string;
+  enabled: boolean;
+}
+
+/**
+ * The subscriptions of the current database with a row in `pg_subscription_rel`
+ * for `schema.table` (and, on a partitioned table, for any of its
+ * partitions, which is where a subscription to a partitioned table lists the
+ * tables it applies to). Read at plan time; `pg_subscription_rel` is
+ * per database and `pg_subscription` is shared, so the join keeps this
+ * database's rows (`subdbid`).
+ */
+export async function subscriptionsOf(client: Pick<PostgresClient, "query">, schema: string, table: string, major: number): Promise<SubscriptionHit[]> {
+  const rel = "pg_catalog.to_regclass(pg_catalog.quote_ident($1) || '.' || pg_catalog.quote_ident($2))";
+  const tables = major >= 12 ? `SELECT relid FROM pg_catalog.pg_partition_tree(${rel})` : `SELECT ${rel}::oid AS relid`;
+  const rows = await client.query<{ subname: string; subenabled: boolean }>(
+    `SELECT DISTINCT s.subname, s.subenabled
+     FROM pg_catalog.pg_subscription_rel sr
+     JOIN pg_catalog.pg_subscription s ON s.oid = sr.srsubid
+     WHERE s.subdbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = pg_catalog.current_database())
+       AND sr.srrelid IN (${tables})
+     ORDER BY s.subname`,
+    [schema, table],
+  );
+  return rows.map((r) => ({ name: r.subname, enabled: r.subenabled }));
+}
+
+/** The Plan phase's refusal for a table that a subscription applies to. */
+export function subscriptionRefusal(where: string, column: string, hits: SubscriptionHit[]): string {
+  return (
+    `${where} is a target of logical replication subscription(s) ${hits.map((h) => `${h.name}${h.enabled ? "" : " (disabled)"}`).join(", ")}. ` +
+    `A subscription's apply worker runs with session_replication_role = replica, where a trigger made by CREATE TRIGGER does not fire, so the dual write would never see a replicated row and the new column of ${column} would go stale ` +
+    `(https://www.postgresql.org/docs/18/runtime-config-client.html#GUC-SESSION-REPLICATION-ROLE). ` +
+    `ENABLE ALWAYS would fire it, but the publisher keeps sending the old column's name and the subscriber applies by name, so the contract (or the switch of a type change) would stop the apply, and one Op cannot change both servers. ` +
+    `Take the table out of the subscription (drop it from the publication and ALTER SUBSCRIPTION ... REFRESH PUBLICATION), or migrate the publisher and the subscriber by hand. A migration of both together is chant #3332.`
+  );
+}

package/src/postgres/migrate/subscriber.e2e.test.ts

@@ -0,0 +1,141 @@
+/**
+ * A table that is the target of a logical replication subscription (#4405),
+ * against two pinned servers with `wal_level = logical`, a publisher and a
+ * subscriber on one Docker network:
+ *
+ * - The fact the refusal rests on: a trigger made by plain `CREATE TRIGGER`
+ *   does not fire for the subscription's apply worker, and one set
+ *   `ENABLE ALWAYS` does.
+ * - The Plan phase refuses the subscriber's table, naming the subscription,
+ *   and stops refusing it once the table is out of the publication and the
+ *   subscription has refreshed.
+ *
+ * Needs Docker; skips cleanly without it.
+ */
+
+import { execFile } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable } from "../testing/server";
+import { connectPostgres, type PostgresClient } from "../live/client";
+import { postgresMigrationPlan, type PostgresMigrationDeps } from "../../op/activities/postgres-migration";
+import { postgresImage, POSTGRES_LATEST_MAJOR } from "../../spec/postgres-pin";
+
+const run = promisify(execFile);
+const enabled = await dockerAvailable();
+const PASSWORD = "chant";
+const suffix = `${process.pid}-${Date.now()}`;
+const network = `chant-sub-net-${suffix}`;
+const dir = mkdtempSync(join(tmpdir(), "chant-pg-subscriber-"));
+const MARKER = { stack: "e2e", env: "test" };
+
+interface Server {
+  name: string;
+  port: string;
+  client: PostgresClient;
+}
+let pub: Server | undefined;
+let sub: Server | undefined;
+
+async function start(role: string): Promise<Server> {
+  const name = `chant-sub-${role}-${suffix}`;
+  await run("docker", [
+    "run", "-d", "--name", name, "--network", network, "-p", "127.0.0.1::5432", "-e", `POSTGRES_PASSWORD=${PASSWORD}`,
+    postgresImage(POSTGRES_LATEST_MAJOR), "-c", "wal_level=logical",
+  ]);
+  const port = (await run("docker", ["port", name, "5432/tcp"])).stdout.trim().split(":").pop()!;
+  for (let i = 0; i < 120; i++) {
+    try {
+      const client = await connectPostgres({ url: `postgres://postgres@127.0.0.1:${port}/postgres`, password: PASSWORD });
+      await client.query("SELECT 1");
+      return { name, port, client };
+    } catch {
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+  }
+  throw new Error(`${name} did not accept a connection`);
+}
+
+beforeAll(async () => {
+  if (!enabled) return;
+  await run("docker", ["network", "create", network]);
+  [pub, sub] = await Promise.all([start("pub"), start("sub")]);
+}, 600_000);
+
+afterAll(async () => {
+  for (const s of [pub, sub]) {
+    await s?.client.end().catch(() => undefined);
+    if (s) await run("docker", ["rm", "-f", "-v", s.name]).catch(() => undefined);
+  }
+  if (enabled) await run("docker", ["network", "rm", network]).catch(() => undefined);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+const waitFor = async (what: string, check: () => Promise<boolean>) => {
+  for (let i = 0; i < 60; i++) {
+    if (await check()) return;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`timed out waiting for ${what}`);
+};
+
+const TABLE = "CREATE TABLE app.users (\n  id bigint PRIMARY KEY,\n  email text NOT NULL\n)";
+const deps = (): PostgresMigrationDeps => ({
+  config: { ownership: MARKER, sql: { profiles: { e2e: { url: `postgres://postgres@127.0.0.1:${sub!.port}/postgres`, password: { env: "PG_E2E_PASSWORD" } } } } },
+  env: { PG_E2E_PASSWORD: PASSWORD },
+  log: () => undefined,
+});
+/** The Plan phase of a rename of email to login, on the subscriber. */
+function planRename(): Promise<string> {
+  writeFileSync(
+    join(dir, "v2.json"),
+    JSON.stringify({
+      dialect: "postgres",
+      postgresMajor: 18,
+      applyOrder: ["app", "users"],
+      objects: [
+        { export: "app", type: "Postgres::Schema", ddl: "CREATE SCHEMA app", dependsOn: [] },
+        { export: "users", type: "Postgres::Table", dependsOn: ["app"], ddl: "CREATE TABLE app.users (\n  id bigint PRIMARY KEY,\n  login text NOT NULL -- previously: email\n)" },
+      ],
+    }),
+  );
+  return postgresMigrationPlan({ table: "app.users", column: "login", buildPath: "v2.json", environment: "e2e", stack: MARKER.stack, ownershipEnv: MARKER.env, cwd: dir } as never, undefined, deps()).then(
+    () => "",
+    (e: unknown) => String((e as Error).message),
+  );
+}
+
+describe.skipIf(!enabled)("a subscription's target table", () => {
+  test("the apply worker fires an ENABLE ALWAYS trigger and not a default one", async () => {
+    for (const s of [pub!, sub!]) await s.client.query(`CREATE SCHEMA app`).then(() => s.client.query(TABLE));
+    await pub!.client.query("CREATE PUBLICATION pub FOR TABLE app.users");
+    await sub!.client.query(`CREATE SUBSCRIPTION sub CONNECTION 'host=${pub!.name} port=5432 user=postgres password=${PASSWORD} dbname=postgres' PUBLICATION pub`);
+    await waitFor("the initial sync", async () => (await sub!.client.query<{ n: string }>("SELECT count(*)::text AS n FROM pg_subscription_rel WHERE srsubstate <> 'r'"))[0]!.n === "0");
+
+    await sub!.client.query("ALTER TABLE app.users ADD COLUMN seen text");
+    await sub!.client.query("CREATE FUNCTION app.mark() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN NEW.seen := TG_NAME; RETURN NEW; END $$");
+    await sub!.client.query("CREATE TRIGGER t_default BEFORE INSERT ON app.users FOR EACH ROW EXECUTE FUNCTION app.mark()");
+    await pub!.client.query("INSERT INTO app.users VALUES (1, 'a')");
+    await waitFor("row 1", async () => (await sub!.client.query("SELECT 1 FROM app.users WHERE id = 1")).length === 1);
+    expect(await sub!.client.query("SELECT seen FROM app.users WHERE id = 1")).toEqual([{ seen: null }]);
+
+    await sub!.client.query("ALTER TABLE app.users ENABLE ALWAYS TRIGGER t_default");
+    await pub!.client.query("INSERT INTO app.users VALUES (2, 'b')");
+    await waitFor("row 2", async () => (await sub!.client.query("SELECT 1 FROM app.users WHERE id = 2")).length === 1);
+    expect(await sub!.client.query("SELECT seen FROM app.users WHERE id = 2")).toEqual([{ seen: "t_default" }]);
+    await sub!.client.query("DROP TRIGGER t_default ON app.users");
+    await sub!.client.query("ALTER TABLE app.users DROP COLUMN seen");
+  }, 300_000);
+
+  test("the Plan phase refuses it naming the subscription, and not once the table has left the publication", async () => {
+    expect(await planRename()).toMatch(/target of logical replication subscription\(s\) sub\b/);
+
+    await pub!.client.query("ALTER PUBLICATION pub DROP TABLE app.users");
+    await sub!.client.query("ALTER SUBSCRIPTION sub REFRESH PUBLICATION");
+    await waitFor("the table to leave the subscription", async () => (await sub!.client.query("SELECT 1 FROM pg_subscription_rel")).length === 0);
+    expect(await planRename()).not.toMatch(/subscription/);
+  }, 300_000);
+});

package/src/postgres/migrate/subscriber.test.ts

@@ -0,0 +1,59 @@
+/**
+ * The Plan phase's read of the subscriptions a table is the target of
+ * (#4405), and its refusal. The e2e is `subscriber.e2e.test.ts`.
+ */
+
+import { describe, expect, test } from "vitest";
+import type { PostgresClient } from "../live/client";
+import { subscriptionRefusal, subscriptionsOf } from "./replication";
+
+function fake(rows: unknown[]) {
+  const calls: { sql: string; params?: readonly unknown[] }[] = [];
+  const client = {
+    query: async (sql: string, params?: readonly unknown[]) => {
+      calls.push({ sql, params });
+      return rows;
+    },
+  } as unknown as Pick<PostgresClient, "query">;
+  return { client, calls };
+}
+
+describe("subscriptionsOf", () => {
+  test("reads pg_subscription_rel and pg_subscription for this database, by schema and table", async () => {
+    const { client, calls } = fake([{ subname: "sub_a", subenabled: true }, { subname: "sub_b", subenabled: false }]);
+    expect(await subscriptionsOf(client, "app", "users", 18)).toEqual([{ name: "sub_a", enabled: true }, { name: "sub_b", enabled: false }]);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.params).toEqual(["app", "users"]);
+    expect(calls[0]!.sql).toContain("pg_catalog.pg_subscription_rel");
+    expect(calls[0]!.sql).toContain("pg_catalog.pg_subscription s");
+    expect(calls[0]!.sql).toContain("s.subdbid");
+  });
+
+  test("a partitioned table is matched through its partitions; before 12 the table alone", async () => {
+    const now = fake([]);
+    await subscriptionsOf(now.client, "app", "events", 18);
+    expect(now.calls[0]!.sql).toContain("pg_partition_tree");
+    const old = fake([]);
+    await subscriptionsOf(old.client, "app", "events", 11);
+    expect(old.calls[0]!.sql).not.toContain("pg_partition_tree");
+  });
+
+  test("no row means no subscription", async () => {
+    expect(await subscriptionsOf(fake([]).client, "app", "users", 18)).toEqual([]);
+  });
+});
+
+describe("subscriptionRefusal", () => {
+  const message = subscriptionRefusal("app.users", "login", [{ name: "sub_a", enabled: true }, { name: "sub_b", enabled: false }]);
+
+  test("names each subscription, and a disabled one as such", () => {
+    expect(message).toContain("sub_a, sub_b (disabled)");
+    expect(message.startsWith("app.users is a target")).toBe(true);
+  });
+
+  test("gives the reason and the way out", () => {
+    expect(message).toContain("session_replication_role = replica");
+    expect(message).toContain("ENABLE ALWAYS");
+    expect(message).toContain("REFRESH PUBLICATION");
+  });
+});