@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/postgres/plan/diff.ts

@@ -215,7 +215,7 @@ function diffUnparsed(key: string, before: PgDiffObject, after: PgDiffObject, ou
 }
 
 /** The kinds (#3911) whose definition has no ALTER: a change is a drop and a create, or (an aggregate's) CREATE OR REPLACE. */
-const REPLACED_KINDS: ReadonlySet<string> = new Set(["composite", "range", "aggregate", "collation", "cast", "eventTrigger"]);
+const REPLACED_KINDS: ReadonlySet<string> = new Set(["composite", "range", "aggregate", "collation", "cast", "eventTrigger", "operator", "operatorClass", "operatorFamily", "statistics"]);
 
 /** What each of {@link REPLACED_KINDS} compares besides its name and comment. */
 const DEFINITION: Readonly<Record<string, readonly string[]>> = {
@@ -225,8 +225,126 @@ const DEFINITION: Readonly<Record<string, readonly string[]>> = {
   collation: ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"],
   cast: ["castMethod", "function", "context"],
   eventTrigger: ["event", "tags", "function"],
+  operator: ["definition"],
+  // A class's members, type, family and default flag have no ALTER; a family has no definition besides its name and method (its identity).
+  operatorClass: ["default", "dataType", "family", "items"],
+  operatorFamily: [],
+  statistics: ["table", "kinds", "targets"],
 };
 
+/** The kinds (#3911) the server alters in place, with the fields that cannot be altered (the object is dropped and created) and those that can. */
+const ALTERED_KINDS: Readonly<Record<string, { recreate: readonly string[]; inPlace: readonly string[]; rule?: PgClassifierRuleId }>> = {
+  foreignDataWrapper: { recreate: [], inPlace: ["handler", "validator", "options"] },
+  foreignServer: { recreate: ["serverType", "wrapper"], inPlace: ["version", "options"] },
+  publication: { recreate: ["allTables"], inPlace: ["tables", "schemas", "publish", "viaRoot", "generatedColumns"] },
+  // ALTER TEXT SEARCH DICTIONARY sets options and cannot change the template; ALTER TEXT SEARCH CONFIGURATION maps token types and cannot change the parser (SQLPG305).
+  textSearchDictionary: { recreate: ["template"], inPlace: ["options"], rule: "SQLPG305" },
+  textSearchConfiguration: { recreate: ["parser"], inPlace: ["mappings"], rule: "SQLPG305" },
+};
+
+/**
+ * A foreign data wrapper's, foreign server's or publication's change: the
+ * comment and each field ALTER reaches in place (SQLPG303); a field it does
+ * not reach (a server's type and wrapper, a publication's FOR ALL TABLES) by
+ * dropping and creating the object (SQLPG300), refused while something
+ * depends on it (SQLPG301).
+ */
+function diffAltered(key: string, before: PgDiffObject, after: PgDiffObject, out: PgChange[]): void {
+  if (!same(before.fields.comment, after.fields.comment)) out.push(change(key, "comment", "SQLPG216", show(before.fields.comment), show(after.fields.comment)));
+  const { recreate, inPlace, rule = "SQLPG303" } = ALTERED_KINDS[after.kind]!;
+  const replaced = recreate.filter((k) => !same(before.fields[k], after.fields[k]));
+  // An object that lives in a schema is another object under another name: a rename between builds is a drop and a create.
+  if (after.schema !== undefined && (before.schema !== after.schema || before.name !== after.name)) replaced.unshift("name");
+  if (replaced.length > 0) {
+    const value = (o: PgDiffObject, k: string) => (k === "name" ? qualified(o) : (show(o.fields[k]) ?? "-"));
+    const was = replaced.map((k) => `${k} ${value(before, k)}`).join("; ");
+    const now = replaced.map((k) => `${k} ${value(after, k)}`).join("; ");
+    if (before.dependents && before.dependents.length > 0) {
+      out.push(change(key, replaced.join(", "), "SQLPG301", was, now, { note: `${before.dependents.join(", ")} depend${before.dependents.length === 1 ? "s" : ""} on it` }));
+    } else out.push(change(key, replaced.join(", "), "SQLPG300", was, now));
+    return;
+  }
+  for (const k of inPlace) if (!same(before.fields[k], after.fields[k])) out.push(change(key, k, rule, show(before.fields[k]), show(after.fields[k])));
+}
+
+/**
+ * Which of an operator's attributes `ALTER OPERATOR ... SET` can change from
+ * what the server holds (the Postgres 18 page, with the supported majors):
+ * RESTRICT and JOIN on every major, set or removed; from 17 COMMUTATOR and
+ * NEGATOR when the operator has none, and HASHES and MERGES when off, never
+ * back. Anything else about the definition is dropped and created.
+ */
+function operatorAlterable(key: string, before: Record<string, unknown>, after: Record<string, unknown>, major: number): boolean {
+  if (key === "restrict" || key === "join") return true;
+  if (major < 17) return false;
+  if (key === "commutator" || key === "negator") return before[key] === undefined && after[key] !== undefined;
+  if (key === "hashes" || key === "merges") return before[key] === undefined && after[key] === "true";
+  return false;
+}
+
+/** An operator's change: in place (SQLPG304) when every attribute that changed is one ALTER OPERATOR reaches, else dropped and created like the other kinds without an ALTER. */
+function diffOperator(key: string, before: PgDiffObject, after: PgDiffObject, out: PgChange[], major: number): void {
+  const bo = (before.fields.definition ?? {}) as Record<string, unknown>;
+  const ao = (after.fields.definition ?? {}) as Record<string, unknown>;
+  const renamed = before.schema !== after.schema || before.name !== after.name || before.signature !== after.signature;
+  // In the order the page lists them, so the statement reads the same whatever the order the options were written in.
+  const ORDER = ["restrict", "join", "commutator", "negator", "hashes", "merges"];
+  const rank = (k: string) => (ORDER.includes(k) ? ORDER.indexOf(k) : ORDER.length);
+  const changed = [...new Set([...Object.keys(bo), ...Object.keys(ao)])].filter((k) => !same(bo[k], ao[k])).sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : 1));
+  if (renamed || !changed.every((k) => operatorAlterable(k, bo, ao, major))) {
+    diffReplaced(key, before, after, out);
+    return;
+  }
+  if (!same(before.fields.comment, after.fields.comment)) out.push(change(key, "comment", "SQLPG216", show(before.fields.comment), show(after.fields.comment)));
+  const note = major < 17 ? undefined : "from 17 ALTER OPERATOR also sets a commutator's or negator's own commutator or negator";
+  for (const k of changed) out.push(change(key, `definition.${k}`, "SQLPG304", show(bo[k]), show(ao[k]), note && (k === "commutator" || k === "negator") ? { note } : {}));
+}
+
+/**
+ * A foreign table's columns, as ALTER FOREIGN TABLE changes them (SQLPG306):
+ * all catalog changes, none reading the remote side. A column is its name
+ * (a rename is a drop and an add); its comment is the generic comment rule.
+ */
+function diffForeignColumns(key: string, before: PgDiffObject, after: PgDiffObject, out: PgChange[]): void {
+  const byName = new Map(before.columns.map((c) => [c.name, c]));
+  const afterNames = new Set(after.columns.map((c) => c.name));
+  for (const b of before.columns) if (!afterNames.has(b.name)) out.push(change(key, `columns.${b.name}`, "SQLPG306", `${b.name} ${b.type ?? ""}`.trim(), undefined));
+  for (const a of after.columns) {
+    const b = byName.get(a.name);
+    if (!b) {
+      out.push(change(key, `columns.${a.name}`, "SQLPG306", undefined, `${a.name} ${a.type ?? ""}`.trim()));
+      continue;
+    }
+    const at = `columns.${a.name}`;
+    if (b.type !== a.type) out.push(change(key, `${at}.type`, "SQLPG306", b.type, a.type));
+    if (b.collate !== a.collate) out.push(change(key, `${at}.collate`, "SQLPG306", b.collate, a.collate));
+    if (b.default !== a.default) out.push(change(key, `${at}.default`, "SQLPG306", b.default, a.default));
+    if (b.notNull !== a.notNull) out.push(change(key, `${at}.notNull`, "SQLPG306", b.notNull ? "NOT NULL" : "NULL", a.notNull ? "NOT NULL" : "NULL"));
+    if (!same(b.options, a.options)) out.push(change(key, `${at}.options`, "SQLPG306", show(b.options), show(a.options)));
+    if (b.comment !== a.comment) out.push(change(key, `${at}.comment`, "SQLPG216", b.comment, a.comment));
+  }
+}
+
+/** A foreign table's CHECK constraints: a dropped one first, so a constraint replaced under its name is dropped before it is added. */
+function diffForeignConstraints(key: string, before: PgDiffObject, after: PgDiffObject, out: PgChange[]): void {
+  const label = (c: CanonicalConstraint) => (c.name ? `${c.name}: ${c.body}` : c.body);
+  const remaining = [...before.constraints];
+  const added: CanonicalConstraint[] = [];
+  const comments: PgChange[] = [];
+  for (const a of after.constraints) {
+    const i = remaining.findIndex((b) => sameConstraint(a, b));
+    if (i < 0) {
+      added.push(a);
+      continue;
+    }
+    const b = remaining.splice(i, 1)[0]!;
+    if (b.comment !== a.comment) comments.push(change(key, `constraints.${a.name ?? b.name}.comment`, "SQLPG216", b.comment, a.comment));
+  }
+  for (const b of remaining) out.push(change(key, `constraints.${b.name ?? b.kind.toLowerCase()}`, "SQLPG306", label(b), undefined));
+  for (const a of added) out.push(change(key, `constraints.${a.name ?? a.kind.toLowerCase()}`, "SQLPG306", undefined, label(a)));
+  out.push(...comments);
+}
+
 /**
  * A type's, aggregate's, collation's, cast's or event trigger's change: its
  * comment in place; its definition by CREATE OR REPLACE AGGREGATE where that
@@ -261,6 +379,15 @@ function diffObject(key: string, before: PgDiffObject, after: PgDiffObject, out:
     const [b, a] = f(name);
     if (!same(b, a)) out.push(change(key, name, rule, show(b), show(a), extra));
   };
+  if (after.kind === "operator") {
+    diffOperator(key, before, after, out, major);
+    return;
+  }
+  // A foreign table moved to another server is another table: ALTER FOREIGN TABLE has no SERVER action.
+  if (after.kind === "foreignTable" && before.schema === after.schema && before.name === after.name && !same(before.fields.server, after.fields.server)) {
+    out.push(change(key, "server", before.dependents && before.dependents.length > 0 ? "SQLPG301" : "SQLPG300", show(before.fields.server), show(after.fields.server), before.dependents && before.dependents.length > 0 ? { note: `${before.dependents.join(", ")} depend${before.dependents.length === 1 ? "s" : ""} on it` } : {}));
+    return;
+  }
   if (REPLACED_KINDS.has(after.kind)) {
     // A cast is named by its types, and an aggregate's argument types are its identity: either changed, between two builds, is another object.
     if (after.kind === "cast" && before.name !== after.name) {
@@ -270,6 +397,10 @@ function diffObject(key: string, before: PgDiffObject, after: PgDiffObject, out:
     diffReplaced(key, before, after, out);
     return;
   }
+  if (after.kind in ALTERED_KINDS) {
+    diffAltered(key, before, after, out);
+    return;
+  }
   if (before.schema !== after.schema || before.name !== after.name) {
     out.push(change(key, "name", after.kind === "index" ? "SQLPG229" : "SQLPG228", qualified(before), qualified(after)));
   }
@@ -386,6 +517,11 @@ function diffObject(key: string, before: PgDiffObject, after: PgDiffObject, out:
       field("attributes", "SQLPG294");
       field("connectionLimit", "SQLPG294");
       break;
+    case "foreignTable":
+      diffForeignColumns(key, before, after, out);
+      diffForeignConstraints(key, before, after, out);
+      field("options", "SQLPG306");
+      break;
     case "table":
       if (!same(before.fields.rowSecurity, after.fields.rowSecurity) || !same(before.fields.forceRowSecurity, after.fields.forceRowSecurity)) {
         const state = (o: PgDiffObject) => (o.fields.rowSecurity ? (o.fields.forceRowSecurity ? "enabled, forced" : "enabled") : o.fields.forceRowSecurity ? "disabled, forced" : "disabled");

package/src/postgres/plan/normalize.ts

@@ -51,6 +51,12 @@ import { stripMarker } from "../../core/ownership";
 import { sequenceDefaults } from "../live/catalog";
 import type {
   AggregateArgDef,
+  OperatorProps,
+  OperatorClassProps,
+  OperatorFamilyProps,
+  ForeignTableProps,
+  TextSearchConfigurationProps,
+  TextSearchDictionaryProps,
   AggregateProps,
   CastProps,
   CheckDef,
@@ -59,6 +65,10 @@ import type {
   CompositeTypeProps,
   DomainProps,
   EventTriggerProps,
+  StatisticsProps,
+  ForeignDataWrapperProps,
+  ForeignServerProps,
+  PublicationProps,
   RangeTypeProps,
   EnumProps,
   ExclusionDef,
@@ -318,6 +328,8 @@ export interface CanonicalColumn {
   collate?: string;
   compression?: string;
   storage?: string;
+  /** A foreign table column's `OPTIONS`, sorted by name. */
+  options?: Record<string, string>;
   comment?: string;
 }
 
@@ -348,6 +360,16 @@ export type CanonicalKind =
   | "collation"
   | "cast"
   | "eventTrigger"
+  | "operator"
+  | "operatorClass"
+  | "operatorFamily"
+  | "foreignTable"
+  | "textSearchConfiguration"
+  | "textSearchDictionary"
+  | "statistics"
+  | "foreignDataWrapper"
+  | "foreignServer"
+  | "publication"
   | "function"
   | "procedure"
   | "trigger"
@@ -393,6 +415,16 @@ const kindOf: Record<string, CanonicalKind> = {
   "Postgres::Collation": "collation",
   "Postgres::Cast": "cast",
   "Postgres::EventTrigger": "eventTrigger",
+  "Postgres::Operator": "operator",
+  "Postgres::OperatorClass": "operatorClass",
+  "Postgres::OperatorFamily": "operatorFamily",
+  "Postgres::ForeignTable": "foreignTable",
+  "Postgres::TextSearchConfiguration": "textSearchConfiguration",
+  "Postgres::TextSearchDictionary": "textSearchDictionary",
+  "Postgres::Statistics": "statistics",
+  "Postgres::ForeignDataWrapper": "foreignDataWrapper",
+  "Postgres::ForeignServer": "foreignServer",
+  "Postgres::Publication": "publication",
   "Postgres::Extension": "extension",
   "Postgres::Function": "function",
   "Postgres::Procedure": "procedure",
@@ -617,7 +649,7 @@ function triggerFields(p: TriggerProps, defaultSchema: string, fields: Record<st
 // ── Types, aggregates, collations, casts, event triggers (#3911) ──────
 
 /** The kinds that live in no schema. */
-const UNPLACED: ReadonlySet<CanonicalKind> = new Set(["schema", "extension", "role", "cast", "eventTrigger"]);
+const UNPLACED: ReadonlySet<CanonicalKind> = new Set(["schema", "extension", "role", "cast", "eventTrigger", "foreignDataWrapper", "foreignServer", "publication"]);
 
 /**
  * A function named where an object calls it (an aggregate's SFUNC, a cast's
@@ -700,6 +732,179 @@ function collationFields(p: CollationProps, fields: Record<string, unknown>): vo
   fields.rules = o.rules;
 }
 
+/** An operator's identity among its overloads: its operand types, `(integer,integer)`, `NONE` for a missing side. */
+export function operatorSignature(p: Pick<OperatorProps, "leftArg" | "rightArg">, defaultSchema: string): string {
+  const side = (t: string | undefined) => (t === undefined ? "NONE" : canonicalArgType(t, defaultSchema));
+  return `(${side(p.leftArg)},${side(p.rightArg)})`;
+}
+
+/**
+ * An operator named where another object names it (a COMMUTATOR or NEGATOR):
+ * `OPERATOR(app.===)`, `app.===` or a bare symbol, which the server looks for
+ * in the new operator's own schema, as `schema.symbol`.
+ */
+export function canonicalOperatorRef(text: string, ownSchema: string): string {
+  const inner = text.trim().replace(/^OPERATOR\s*\(\s*(.*?)\s*\)$/is, "$1");
+  const m = /^("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*\.\s*(\S.*)$/s.exec(inner);
+  return `${quoteIdent(m ? identValue(m[1]!) : ownSchema)}.${(m ? m[2]! : inner).trim()}`;
+}
+
+/** An operator's definition as compared: each function and operator named canonically, a flag only when set. */
+function operatorOptions(p: OperatorProps, ownSchema: string, defaultSchema: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(p.options)) {
+    if (k === "function" || k === "restrict" || k === "join") out[k] = canonicalFunctionName(v, defaultSchema);
+    else if (k === "commutator" || k === "negator") out[k] = canonicalOperatorRef(v, ownSchema);
+    else if (k === "hashes" || k === "merges") {
+      if (isTrue(v)) out[k] = "true";
+    } else out[k] = defValue(v);
+  }
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => (a < b ? -1 : 1)));
+}
+
+/**
+ * A name where an object is named (a text search parser, template or
+ * dictionary, an operator family): the schema left off when it is
+ * `pg_catalog` or the default schema, since a bare name is looked for in both.
+ * The catalog prints every schema, so both sides are brought to this form.
+ */
+export function canonicalRef(text: string, defaultSchema: string): string {
+  const pieces = canonicalName(text).split(/\.(?=(?:[^"]*"[^"]*")*[^"]*$)/);
+  if (pieces.length >= 2) {
+    const schema = identValue(pieces[0]!);
+    return schema === "pg_catalog" || schema === defaultSchema ? pieces.slice(1).join(".") : pieces.join(".");
+  }
+  return pieces[0]!;
+}
+
+/** An operator named in an operator class: `OPERATOR(app.<<)`, `app.<<` or a bare symbol, by `canonicalRef`'s rule for the schema. */
+export function canonicalOperatorName(text: string, defaultSchema: string): string {
+  const inner = text.trim().replace(/^OPERATOR\s*\(\s*(.*?)\s*\)$/is, "$1").trim();
+  const m = /^("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*\.\s*(\S.*)$/s.exec(inner);
+  if (!m) return inner;
+  const schema = identValue(m[1]!);
+  return schema === "pg_catalog" || schema === defaultSchema ? m[2]!.trim() : `${quoteIdent(schema)}.${m[2]!.trim()}`;
+}
+
+/** A comma list split at its top level: `numeric(12,2), text` is two items. */
+function splitTopLevel(text: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of text) {
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    if (ch === "," && depth === 0) {
+      out.push(current.trim());
+      current = "";
+    } else current += ch;
+  }
+  if (current.trim() !== "") out.push(current.trim());
+  return out;
+}
+
+/**
+ * The operand types a support function of an operator class is registered
+ * for when `FUNCTION n (left, right)` does not say (sql-createopclass): a
+ * B-tree comparison function's (1) and a hash function's (1, 2) are the
+ * function's own input types, a B-tree `in_range` function's (3) its first
+ * and third, and every other support function's the class's type. The catalog
+ * always stores both, so a declaration is brought to them.
+ */
+function supportTypes(method: string, number: number, classType: string, args: readonly string[]): [string, string] {
+  if (method === "btree" && number === 1) return [args[0] ?? classType, args[1] ?? args[0] ?? classType];
+  if (method === "btree" && number === 3) return [args[0] ?? classType, args[2] ?? classType];
+  if (method === "hash" && (number === 1 || number === 2)) return [args[0] ?? classType, args[0] ?? classType];
+  return [classType, classType];
+}
+
+/** An operator class as compared: its type, family, default flag and members, each member canonical and the list sorted. */
+function operatorClassFields(p: OperatorClassProps, schema: string, defaultSchema: string, fields: Record<string, unknown>): void {
+  const type = canonicalType(p.dataType, defaultSchema)!;
+  fields.default = p.default === true;
+  fields.dataType = type;
+  // A class with no FAMILY is in a family of its own name; so is one that names that family.
+  const own = canonicalRef(`${quoteIdent(schema)}.${quoteIdent(p.name)}`, defaultSchema);
+  const named = p.family === undefined ? own : /^\s*("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*$/.test(p.family) && identValue(p.family.trim()) === p.name ? own : canonicalRef(p.family, defaultSchema);
+  fields.family = named === own ? undefined : named;
+  const side = (t: string) => (t.trim().toUpperCase() === "NONE" ? "NONE" : canonicalArgType(t, defaultSchema));
+  const members = p.items.map((i): { rank: number; number: number; text: string } => {
+    if (i.kind === "storage") return { rank: 2, number: 0, text: `storage ${canonicalType(i.type, defaultSchema)}` };
+    const n = Number(i.number);
+    if (i.kind === "operator") {
+      const [l, r] = i.types !== undefined ? splitTopLevel(i.types) : [type, type];
+      const sorted = i.orderBy !== undefined ? ` for order by ${canonicalRef(i.orderBy, defaultSchema)}` : "";
+      return { rank: 0, number: n, text: `operator ${n} ${canonicalOperatorName(i.operator, defaultSchema)} (${side(l ?? type)},${side(r ?? l ?? type)})${sorted}` };
+    }
+    const args = splitTopLevel(i.args).map((a) => canonicalArgType(a, defaultSchema));
+    const given = i.types !== undefined ? splitTopLevel(i.types).map(side) : undefined;
+    const [l, r] = given ? [given[0]!, given[1] ?? given[0]!] : supportTypes(p.method, n, type, args);
+    return { rank: 1, number: n, text: `function ${n} (${l},${r}) ${canonicalFunctionName(i.function, defaultSchema)}(${args.join(",")})` };
+  });
+  members.sort((a, b) => a.rank - b.rank || a.number - b.number || (a.text < b.text ? -1 : 1));
+  fields.items = members.map((m) => m.text);
+}
+
+/** A dictionary option's value as compared: a string constant's value, a quoted name's, a bare word folded, a number as written. */
+function dictionaryValue(v: string): string {
+  const t = v.trim();
+  if (/^([Ee]?'|\$)/.test(t)) return stringValue(t) ?? t;
+  if (/^"/.test(t)) return identValue(t);
+  return t.toLowerCase();
+}
+
+/** A text search configuration's mappings as compared: each token type to its dictionaries in order, sorted by token type. */
+function mappingFields(p: TextSearchConfigurationProps, defaultSchema: string): Record<string, string[]> | undefined {
+  const out: Record<string, string[]> = {};
+  for (const m of p.mappings) for (const t of m.tokens) out[t.toLowerCase()] = m.dictionaries.map((d) => canonicalRef(d, defaultSchema));
+  const entries = Object.entries(out).sort(([a], [b]) => (a < b ? -1 : 1));
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+/** An `OPTIONS (...)` list as compared: by name, none as nothing. */
+function sortedOptions(options: Record<string, string> | undefined): Record<string, string> | undefined {
+  const entries = Object.entries(options ?? {}).sort(([a], [b]) => (a < b ? -1 : 1));
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+const STATISTICS_ALL = ["dependencies", "mcv", "ndistinct"];
+
+/**
+ * The kinds of statistics gathered, sorted. Left out, the server builds all
+ * three, except for a lone expression, which gets none of them (only the
+ * expression's own statistics); `pg_get_statisticsobjdef` prints the list only
+ * when it is not that default.
+ */
+export function statisticsKinds(kinds: readonly string[] | undefined, targets: readonly string[]): string[] | undefined {
+  if (kinds && kinds.length > 0) {
+    const sorted = [...new Set(kinds.map((k) => k.toLowerCase()))].sort();
+    return sorted.join() === STATISTICS_ALL.join() ? undefined : sorted;
+  }
+  const lone = targets.length === 1 && !/^"?[A-Za-z_][A-Za-z0-9_$]*"?$/.test(targets[0]!.trim());
+  return lone ? ["none"] : undefined;
+}
+
+/** Every action a publication publishes when `publish` is not given. */
+const PUBLISH_ALL = ["delete", "insert", "truncate", "update"];
+
+/** A publication as compared: its tables with their column lists and row filters, its schemas, and each option at its default left out. */
+function publicationFields(p: PublicationProps, defaultSchema: string, fields: Record<string, unknown>): void {
+  fields.allTables = p.allTables === true;
+  const tables = p.tables.map((t) => ({
+    table: canonicalName(t.tableName, defaultSchema),
+    ...(t.columns && t.columns.length > 0 ? { columns: [...t.columns].sort() } : {}),
+    ...(t.where ? { where: canonicalExpr(t.where) } : {}),
+  }));
+  fields.tables = tables.length > 0 ? tables.sort((a, b) => (a.table < b.table ? -1 : 1)) : undefined;
+  fields.schemas = p.schemas.length > 0 ? p.schemas.map((s) => quoteIdent(identValue(s))).sort() : undefined;
+  const o = p.options;
+  const publish = o.publish === undefined ? PUBLISH_ALL : [...new Set(defValue(o.publish).split(",").map((x) => x.trim().toLowerCase()).filter(Boolean))].sort();
+  fields.publish = publish.join() === PUBLISH_ALL.join() ? undefined : publish;
+  fields.viaRoot = isTrue(o.publish_via_partition_root);
+  const generated = o.publish_generated_columns === undefined ? "none" : defValue(o.publish_generated_columns);
+  fields.generatedColumns = generated === "none" ? undefined : generated;
+}
+
 /** A cast's name, `(source AS target)`, its types canonical. */
 export const castName = (p: Pick<CastProps, "sourceType" | "targetType">, defaultSchema: string): string =>
   `(${canonicalType(p.sourceType, defaultSchema)} AS ${canonicalType(p.targetType, defaultSchema)})`;
@@ -774,6 +979,77 @@ export function canonicalPgObject(entityType: string, props: Record<string, unkn
       fields.function = canonicalFunctionName(p.functionName, defaultSchema);
       break;
     }
+    case "operator": {
+      const p = props as unknown as OperatorProps;
+      base.signature = operatorSignature(p, defaultSchema);
+      fields.definition = operatorOptions(p, base.schema!, defaultSchema);
+      break;
+    }
+    case "operatorClass":
+      operatorClassFields(props as unknown as OperatorClassProps, base.schema!, defaultSchema, fields);
+      base.signature = ` USING ${(props as unknown as OperatorClassProps).method}`;
+      break;
+    case "operatorFamily":
+      base.signature = ` USING ${(props as unknown as OperatorFamilyProps).method}`;
+      break;
+    case "textSearchDictionary": {
+      const p = props as unknown as TextSearchDictionaryProps;
+      fields.template = canonicalRef(p.template, defaultSchema);
+      fields.options = sortedOptions(Object.fromEntries(Object.entries(p.options).map(([k, v]) => [k.toLowerCase(), dictionaryValue(v)])));
+      break;
+    }
+    case "textSearchConfiguration": {
+      const p = props as unknown as TextSearchConfigurationProps;
+      fields.parser = canonicalRef(p.parser, defaultSchema);
+      fields.mappings = mappingFields(p, defaultSchema);
+      break;
+    }
+    case "foreignTable": {
+      const p = props as unknown as ForeignTableProps;
+      p.columns.forEach((c: ColumnDef, position) => {
+        const options = sortedOptions(c.options);
+        columns.push({
+          name: c.name,
+          position,
+          type: canonicalType(c.type, defaultSchema),
+          notNull: c.notNull === true,
+          default: canonicalExpr(c.default),
+          collate: c.collate ? canonicalName(c.collate) : undefined,
+          comment: comment(c.comment),
+          ...(options ? { options } : {}),
+        });
+      });
+      for (const c of p.checks) constraints.push({ kind: "CHECK", name: c.name, body: ["check", canonicalExpr(c.expr), c.noInherit ? "no inherit" : ""].filter(Boolean).join(" "), ...(c.notValid ? { notValid: true } : {}), comment: comment(c.comment) });
+      fields.server = quoteIdent(p.serverName);
+      fields.options = sortedOptions(p.options);
+      break;
+    }
+    case "statistics": {
+      const p = props as unknown as StatisticsProps;
+      fields.table = canonicalName(p.tableName, defaultSchema);
+      const targets = p.targets.map((t) => canonicalExpr(t)!).sort();
+      fields.targets = targets;
+      fields.kinds = statisticsKinds(p.kinds, p.targets);
+      break;
+    }
+    case "foreignDataWrapper": {
+      const p = props as unknown as ForeignDataWrapperProps;
+      fields.handler = p.handlerName && !p.noHandler ? canonicalFunctionName(p.handlerName, defaultSchema) : undefined;
+      fields.validator = p.validatorName && !p.noValidator ? canonicalFunctionName(p.validatorName, defaultSchema) : undefined;
+      fields.options = sortedOptions(p.options);
+      break;
+    }
+    case "foreignServer": {
+      const p = props as unknown as ForeignServerProps;
+      fields.serverType = p.serverType;
+      fields.version = p.version;
+      fields.wrapper = quoteIdent(identValue(p.wrapperName));
+      fields.options = sortedOptions(p.options);
+      break;
+    }
+    case "publication":
+      publicationFields(props as unknown as PublicationProps, defaultSchema, fields);
+      break;
     case "function":
     case "procedure": {
       const p = props as unknown as RoutineProps;

package/src/postgres/plan/rules.ts

@@ -360,15 +360,15 @@ export const PG_CLASSIFIER_RULES = {
   SQLPG300: rule(
     "SQLPG300",
     "metadata",
-    "Drop and create a type, aggregate, collation, cast or event trigger",
-    "A composite or range type's definition, a collation's, a cast's and an event trigger's have no ALTER, and an aggregate's argument types, state type and final function cannot be replaced: the object is dropped and created in one transaction. Nothing on the server depends on it (a column, a view, a function or a cast would make the DROP fail); the locks are on its catalog rows only.",
+    "Drop and create a type, aggregate, collation, cast, event trigger, operator, operator class or family, foreign table's server, text search object, statistics object, foreign server or publication",
+    "A composite or range type's definition, a collation's, a cast's, an event trigger's, an operator's function and operands, and any attribute of it that SQLPG304 does not alter, an operator class's members, type, family and default flag, an operator family's index method, and extended statistics' have no ALTER (ALTER OPERATOR CLASS and ALTER OPERATOR FAMILY change a name, an owner or a schema only), an aggregate's argument types, state type and final function cannot be replaced, and neither can a foreign server's type or wrapper, a foreign table's server, a text search configuration's parser, a text search dictionary's template or a publication's FOR ALL TABLES: the object is dropped and created in one transaction. Nothing on the server depends on it (a column, a view, an index, a function or a cast would make the DROP fail); the locks are on its catalog rows only. Dropped statistics are empty until the next ANALYZE, and a publication that is dropped stops its subscribers until it is created again.",
     `${DOCS}/sql-createtype.html`,
   ),
   SQLPG301: rule(
     "SQLPG301",
     "expand",
-    "Change a type, aggregate, collation or cast that other objects depend on",
-    "No ALTER makes the change, and DROP refuses while a column, a view, a function or another object depends on the object. Create the new definition under another name, move what depends on it, then drop the old.",
+    "Change a type, aggregate, collation, cast, operator, operator class, text search object, foreign table's server, foreign server or publication that other objects depend on",
+    "No ALTER makes the change, and DROP refuses while a column, a view, an index, a function or another object depends on the object. Create the new definition under another name, move what depends on it, then drop the old.",
     `${DOCS}/sql-droptype.html`,
   ),
   SQLPG302: rule(
@@ -378,6 +378,34 @@ export const PG_CLASSIFIER_RULES = {
     "CREATE OR REPLACE AGGREGATE (14 and later) replaces the aggregate's functions and options in the catalog; no table is locked. Its argument types, its result and its kind (plain, ordered-set, hypothetical-set) have to stay the same, so a change of the state type or the final function is dropped and created instead (SQLPG300).",
     `${DOCS}/sql-createaggregate.html`,
   ),
+  SQLPG303: rule(
+    "SQLPG303",
+    "metadata",
+    "Alter a foreign data wrapper, foreign server or publication in place",
+    "ALTER FOREIGN DATA WRAPPER (handler, validator, options), ALTER SERVER (version, options) and ALTER PUBLICATION (SET options, ADD and DROP TABLE and TABLES IN SCHEMA) change the object's catalog rows under a brief lock; no table is rewritten. A publication's change reaches its subscribers as the walsender next reads it: a table added is not copied to a subscription until the subscriber runs REFRESH PUBLICATION.",
+    `${DOCS}/sql-alterpublication.html`,
+  ),
+  SQLPG304: rule(
+    "SQLPG304",
+    "metadata",
+    "Alter an operator in place",
+    "ALTER OPERATOR ... SET changes the operator's catalog row under a brief lock; no index or table is read. RESTRICT and JOIN can be set or removed (NONE) on every supported major. From 17, COMMUTATOR and NEGATOR can be set when the operator has none, and HASHES and MERGES turned on, never off (the Postgres 18 page: \"Can only be changed if the operator does not have an existing commutator\", \"Can only be enabled and not disabled\"); setting a commutator or negator also sets the other operator's. On 14 to 16 only RESTRICT and JOIN are alterable, so any other change drops and creates the operator (SQLPG300), as does a change of function or operands on any major.",
+    `${DOCS}/sql-alteroperator.html`,
+  ),
+  SQLPG305: rule(
+    "SQLPG305",
+    "metadata",
+    "Alter a text search configuration's mappings or a dictionary's options in place",
+    "ALTER TEXT SEARCH CONFIGURATION ADD MAPPING, ALTER MAPPING and DROP MAPPING change the token types mapped to dictionaries; ALTER TEXT SEARCH DICTIONARY sets a template's options, and an option named with no value is removed. Both change catalog rows under a brief lock and leave the parser or template as it is, so a parser or template change is dropped and created (SQLPG300). A tsvector already stored keeps the tokens it was built with: rebuild the columns and indexes that hold one when the mappings or options change what a word becomes. The same applies on 14 to 18.",
+    `${DOCS}/sql-altertsconfig.html`,
+  ),
+  SQLPG306: rule(
+    "SQLPG306",
+    "metadata",
+    "Alter a foreign table in place",
+    "ALTER FOREIGN TABLE adds and drops columns, changes a column's type, default, NOT NULL and OPTIONS, adds and drops CHECK and NOT NULL constraints, and sets the table's OPTIONS, all in the catalog. Nothing is checked against the remote side and no row is rewritten or scanned (\"It is the user's responsibility to ensure that the table definition matches the remote side\"), so a CHECK is added with no validation pass. A foreign table's server cannot be altered, so a change of server is dropped and created (SQLPG300).",
+    `${DOCS}/sql-alterforeigntable.html`,
+  ),
   SQLPG270: rule("SQLPG270", "drop", "Drop an object", "The object and, for a table, a materialized view or a sequence, its data are gone.", `${DOCS}/sql-droptable.html`),
 } as const satisfies Record<string, PgClassifierRule>;
 

package/src/postgres/plan/schema.ts

@@ -106,7 +106,7 @@ export function pgSchemaFromBuildFile(path: string, defaultSchema = "public"): P
  */
 export function pgNamespace(kind: string): string {
   if (kind === "schema" || kind === "extension" || kind === "trigger" || kind === "policy" || kind === "role") return kind;
-  if (kind === "collation" || kind === "cast" || kind === "eventTrigger") return kind;
+  if (kind === "collation" || kind === "cast" || kind === "eventTrigger" || kind === "operator" || kind === "operatorClass" || kind === "operatorFamily" || kind === "textSearchConfiguration" || kind === "textSearchDictionary" || kind === "statistics" || kind === "foreignDataWrapper" || kind === "foreignServer" || kind === "publication") return kind;
   if (kind === "grant" || kind === "defaultPrivileges") return "grant";
   if (kind === "enum" || kind === "domain" || kind === "composite" || kind === "range") return "type";
   if (kind === "function" || kind === "procedure" || kind === "aggregate") return "routine";

package/src/postgres/plan/statements.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "vitest";
+import { classifyPgStatements } from "./statements";
+
+const one = (sql: string) => classifyPgStatements([sql])[0]!;
+const rules = (sql: string) => one(sql).changes.map((c) => c.rule);
+
+describe("Postgres statements", () => {
+  test("CREATE INDEX without CONCURRENTLY is SQLPG241 with its SHARE lock", () => {
+    const v = one("CREATE INDEX orders_status_idx ON app.orders (status)");
+    expect(v.outcome).toBe("classified");
+    expect(v.changes).toMatchObject([{ rule: "SQLPG241", class: "concurrently", lock: "SHARE" }]);
+  });
+
+  test("CREATE INDEX CONCURRENTLY is SQLPG240", () => {
+    expect(one("CREATE UNIQUE INDEX CONCURRENTLY i ON t (a)").changes).toMatchObject([{ rule: "SQLPG240", lock: "SHARE UPDATE EXCLUSIVE" }]);
+  });
+
+  test("an index on a table the file creates needs no CONCURRENTLY", () => {
+    const [t, i] = classifyPgStatements(["CREATE TABLE t (id bigint PRIMARY KEY, a int)", "CREATE INDEX i ON t (a)"]);
+    expect(t!.changes[0]!.rule).toBe("SQLPG200");
+    expect(i!.changes[0]!.rule).toBe("SQLPG200");
+  });
+
+  test("ADD COLUMN splits by what the table must compute", () => {
+    expect(rules("ALTER TABLE t ADD COLUMN a int")).toEqual(["SQLPG201"]);
+    expect(rules("ALTER TABLE t ADD COLUMN a int NOT NULL DEFAULT 0")).toEqual(["SQLPG201"]);
+    expect(rules("ALTER TABLE t ADD COLUMN a int NOT NULL")).toEqual(["SQLPG203"]);
+    expect(rules("ALTER TABLE t ADD COLUMN a uuid DEFAULT gen_random_uuid()")).toEqual(["SQLPG202"]);
+    expect(rules("ALTER TABLE t ADD COLUMN a int GENERATED ALWAYS AS (b + 1) STORED")).toEqual(["SQLPG202"]);
+  });
+
+  test("a column type change is undecided between SQLPG206 and SQLPG207", () => {
+    const v = one("ALTER TABLE t ALTER COLUMN a TYPE bigint");
+    expect(v.outcome).toBe("undecided");
+    expect(v.candidates!.map((c) => c.rule)).toEqual(["SQLPG206", "SQLPG207"]);
+    expect(one("ALTER TABLE t ALTER COLUMN a TYPE int USING a::int").candidates!.map((c) => c.rule)).toEqual(["SQLPG206", "SQLPG207", "SQLPG208"]);
+  });
+
+  test("several actions in one ALTER TABLE are each classified", () => {
+    expect(rules("ALTER TABLE t ADD COLUMN a int, DROP COLUMN b, ALTER COLUMN c SET NOT NULL")).toEqual(["SQLPG201", "SQLPG204", "SQLPG210"]);
+    expect(one("ALTER TABLE t DROP COLUMN b").changes[0]!.destructive).toBe(true);
+  });
+
+  test("constraints", () => {
+    expect(rules("ALTER TABLE t ADD CONSTRAINT fk FOREIGN KEY (a) REFERENCES u (id) NOT VALID")).toEqual(["SQLPG217"]);
+    expect(rules("ALTER TABLE t ADD CONSTRAINT fk FOREIGN KEY (a) REFERENCES u (id)")).toEqual(["SQLPG219"]);
+    expect(rules("ALTER TABLE t ADD CONSTRAINT c CHECK (a > 0)")).toEqual(["SQLPG218"]);
+    expect(rules("ALTER TABLE t ADD PRIMARY KEY (id)")).toEqual(["SQLPG221"]);
+    expect(rules("ALTER TABLE t VALIDATE CONSTRAINT fk")).toEqual(["SQLPG220"]);
+    expect(rules("ALTER TABLE t DROP CONSTRAINT fk")).toEqual(["SQLPG223"]);
+  });
+
+  test("renames", () => {
+    expect(rules("ALTER TABLE t RENAME COLUMN a TO b")).toEqual(["SQLPG205"]);
+    expect(rules("ALTER TABLE t RENAME TO u")).toEqual(["SQLPG228"]);
+    expect(rules("ALTER INDEX i RENAME TO j")).toEqual(["SQLPG229"]);
+  });
+
+  test("DROP, GRANT, COMMENT and row security go through the parser or the verb", () => {
+    expect(rules("DROP INDEX CONCURRENTLY i")).toEqual(["SQLPG242"]);
+    expect(rules("DROP TABLE t")).toEqual(["SQLPG270"]);
+    expect(rules("GRANT SELECT ON TABLE t TO reader")).toEqual(["SQLPG296"]);
+    expect(rules("REVOKE SELECT ON TABLE t FROM reader")).toEqual(["SQLPG297"]);
+    expect(rules("COMMENT ON TABLE t IS 'x'")).toEqual(["SQLPG216"]);
+    expect(rules("ALTER TABLE t ENABLE ROW LEVEL SECURITY")).toEqual(["SQLPG293"]);
+  });
+
+  test("functions and views", () => {
+    expect(rules("CREATE OR REPLACE FUNCTION f() RETURNS int LANGUAGE sql AS $$ select 1; $$")).toEqual(["SQLPG280"]);
+    expect(one("CREATE OR REPLACE VIEW v AS SELECT 1 AS a").candidates!.map((c) => c.rule)).toEqual(["SQLPG250", "SQLPG251"]);
+    expect(rules("CREATE VIEW v AS SELECT 1 AS a")).toEqual(["SQLPG200"]);
+  });
+
+  test("data statements and unknown ALTERs", () => {
+    expect(one("UPDATE t SET a = 1").outcome).toBe("data");
+    expect(one("ALTER TABLE t OWNER TO app").outcome).toBe("unclassified");
+  });
+});