@intentius/chant-lexicon-sql 0.124.48 → 0.124.49

package/src/postgres/parser.ts

@@ -113,6 +113,8 @@ export interface ColumnNode {
   notNullName?: string;
   default?: Span;
   generated?: { kind: "stored" | "virtual" | "identity"; expr?: Span; always: boolean; options?: Span };
+  /** A foreign table column's `OPTIONS (...)`. */
+  options?: GenericOption[];
   /** Column constraints other than NOT NULL, NULL, DEFAULT and GENERATED. */
   constraints: ConstraintNode[];
 }
@@ -298,6 +300,66 @@ export interface GenericOption {
   value: Span;
 }
 
+/** `CREATE FOREIGN TABLE [IF NOT EXISTS] name (columns) SERVER server [OPTIONS (...)]`. */
+export interface ForeignTableNode {
+  statement: "foreignTable";
+  /** Clauses the parser does not know (#3872), kept in the DDL as written; absent when there are none. */
+  unknown?: UnknownClause[];
+  ifNotExists: boolean;
+  name: NameNode;
+  columns: ColumnNode[];
+  constraints: ConstraintNode[];
+  server: NameNode;
+  options: GenericOption[];
+}
+
+/** One member of an operator class: an operator, a support function, or the storage type. */
+export type OperatorClassItem =
+  | { kind: "operator"; number: Span; operator: NameNode; types?: Span; orderBy?: NameNode }
+  | { kind: "function"; number: Span; types?: Span; function: NameNode; args: Span }
+  | { kind: "storage"; type: Span };
+
+/** `CREATE OPERATOR CLASS name [DEFAULT] FOR TYPE type USING method [FAMILY family] AS item, ...`. */
+export interface OperatorClassNode {
+  statement: "operatorClass";
+  name: NameNode;
+  default: boolean;
+  type: Span;
+  /** The index access method, folded. */
+  method: string;
+  family?: NameNode;
+  items: OperatorClassItem[];
+}
+
+/** `CREATE OPERATOR FAMILY name USING method`. */
+export interface OperatorFamilyNode {
+  statement: "operatorFamily";
+  name: NameNode;
+  method: string;
+}
+
+/** `CREATE TEXT SEARCH DICTIONARY name (TEMPLATE = t [, option = value, ...])`; the template is the `template` option. */
+export interface TextSearchDictionaryNode {
+  statement: "textSearchDictionary";
+  name: NameNode;
+  options: DefElem[];
+}
+
+/** `CREATE TEXT SEARCH CONFIGURATION name (PARSER = p)`. */
+export interface TextSearchConfigurationNode {
+  statement: "textSearchConfiguration";
+  name: NameNode;
+  options: DefElem[];
+}
+
+/** `ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type, ... WITH dictionary, ...`: a configuration's mapping, written after its CREATE. */
+export interface TextSearchMappingNode {
+  statement: "textSearchMapping";
+  name: NameNode;
+  tokens: Array<{ name: string; span: Span }>;
+  dictionaries: NameNode[];
+}
+
 /** `CREATE FOREIGN DATA WRAPPER name [HANDLER f | NO HANDLER] [VALIDATOR f | NO VALIDATOR] [OPTIONS (...)]`. */
 export interface ForeignDataWrapperNode {
   statement: "foreignDataWrapper";
@@ -462,6 +524,8 @@ export interface CommentNode {
   on?: NameNode;
   /** For `COMMENT ON FUNCTION f(...)` and `AGGREGATE a(...)`: the parameter list, parentheses excluded. */
   args?: Span;
+  /** For `COMMENT ON OPERATOR CLASS c USING m` and `OPERATOR FAMILY`: the index method, folded. */
+  using?: string;
   /** For `COMMENT ON CAST (source AS target)`: the two types. */
   cast?: { source: Span; target: Span };
   /** The comment, a string, or undefined for `IS NULL`. */
@@ -482,6 +546,12 @@ export type StatementNode =
   | CastNode
   | EventTriggerNode
   | OperatorNode
+  | OperatorClassNode
+  | OperatorFamilyNode
+  | ForeignTableNode
+  | TextSearchDictionaryNode
+  | TextSearchConfigurationNode
+  | TextSearchMappingNode
   | StatisticsNode
   | ForeignDataWrapperNode
   | ForeignServerNode
@@ -845,7 +915,7 @@ class PgParser extends SqlCursor {
     return node;
   }
 
-  private column(typed: boolean): ColumnNode {
+  private column(typed: boolean, foreign = false): ColumnNode {
     const { text, span } = this.nameTok("a column name");
     const col: ColumnNode = { name: text, nameSpan: span, constraints: [] };
     if (!typed) this.acceptSeq("WITH", "OPTIONS");
@@ -854,7 +924,10 @@ class PgParser extends SqlCursor {
     if (typed && !bare && !this.stopsAt(COLUMN_CLAUSE)) col.type = this.typeName();
     else if (typed) this.fail("expected a column type");
     for (;;) {
-      if (this.accept("COMPRESSION")) col.compression = this.expr(COLUMN_CLAUSE);
+      if (foreign && kw(this.peek(), "OPTIONS") && this.isPunct("(", 1)) {
+        this.p++;
+        col.options = this.genericOptions();
+      } else if (this.accept("COMPRESSION")) col.compression = this.expr(COLUMN_CLAUSE);
       else if (this.accept("STORAGE")) col.storage = this.expr(COLUMN_CLAUSE);
       else if (this.accept("COLLATE")) col.collate = this.expr(COLUMN_CLAUSE);
       else if (!this.columnConstraint(col) && !this.unknownClause(COLUMN_WORDS, { inList: true, column: text || undefined })) break;
@@ -1070,6 +1143,7 @@ class PgParser extends SqlCursor {
     if (this.accept("GRANT")) return this.grant(false, false);
     if (this.accept("REVOKE")) return this.grant(true, false);
     if (this.acceptSeq("ALTER", "DEFAULT", "PRIVILEGES")) return this.defaultPrivileges();
+    if (this.acceptSeq("ALTER", "TEXT", "SEARCH", "CONFIGURATION")) return this.textSearchMapping();
     if (this.acceptSeq("ALTER", "TABLE")) return this.rowSecurity();
     this.expect("CREATE");
     const orReplace = this.acceptSeq("OR", "REPLACE");
@@ -1089,8 +1163,21 @@ class PgParser extends SqlCursor {
       if (this.accept("COLLATION")) return this.collation();
       if (this.accept("CAST")) return this.cast();
       if (this.acceptSeq("EVENT", "TRIGGER")) return this.eventTrigger();
-      if (this.accept("OPERATOR")) return this.operator();
+      if (this.accept("OPERATOR")) {
+        // CLASS and FAMILY are words an operator's schema may be named: `class.+` is still an operator.
+        if (kw(this.peek(), "CLASS") && !this.isPunct(".", 1)) {
+          this.p++;
+          return this.operatorClass();
+        }
+        if (kw(this.peek(), "FAMILY") && !this.isPunct(".", 1)) {
+          this.p++;
+          return this.operatorFamily();
+        }
+        return this.operator();
+      }
+      if (this.acceptSeq("TEXT", "SEARCH")) return this.textSearch();
       if (this.accept("STATISTICS")) return this.statistics();
+      if (this.acceptSeq("FOREIGN", "TABLE")) return this.foreignTable();
       if (this.acceptSeq("FOREIGN", "DATA", "WRAPPER")) return this.foreignDataWrapper();
       if (this.accept("SERVER")) return this.foreignServer();
       if (this.accept("PUBLICATION")) return this.publication();
@@ -1103,7 +1190,7 @@ class PgParser extends SqlCursor {
     const recursive = this.accept("RECURSIVE");
     if (!orReplace && !recursive && persistence === undefined && this.acceptSeq("MATERIALIZED", "VIEW")) return this.view(true, false, false, false);
     if (this.accept("VIEW")) return this.view(false, orReplace, persistence === "temporary", recursive);
-    return this.fail("expected SCHEMA, TABLE, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, TRIGGER, EVENT TRIGGER, COLLATION, CAST, OPERATOR, STATISTICS, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, POLICY or ROLE");
+    return this.fail("expected SCHEMA, TABLE, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, TRIGGER, EVENT TRIGGER, COLLATION, CAST, OPERATOR, OPERATOR CLASS, OPERATOR FAMILY, TEXT SEARCH CONFIGURATION, TEXT SEARCH DICTIONARY, STATISTICS, FOREIGN TABLE, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, POLICY or ROLE");
   }
 
   private schema(): SchemaNode {
@@ -1372,7 +1459,6 @@ class PgParser extends SqlCursor {
   }
 
   private operator(): OperatorNode {
-    if (kw(this.peek(), "CLASS", "FAMILY") && !this.isPunct(".", 1)) this.fail("expected the operator's name (CREATE OPERATOR CLASS and CREATE OPERATOR FAMILY are not declared)");
     const name = this.operatorName();
     const options = this.definition("an operator option");
     this.checkDefinition(options, OPERATOR_OPTIONS, [], "an operator");
@@ -1380,6 +1466,122 @@ class PgParser extends SqlCursor {
     return { statement: "operator", name, options };
   }
 
+  /** The member list of `CREATE OPERATOR CLASS ... AS`: an operator, a support function or the storage type. */
+  private operatorClassItem(): OperatorClassItem {
+    const number = (): Span => {
+      const t = this.next();
+      if (t.kind !== "number" && t.kind !== "ref") this.fail("expected the strategy or support number", t);
+      return this.span(this.idx(-1), t.kind === "ref" ? [t.part] : []);
+    };
+    if (this.accept("OPERATOR")) {
+      const item: Extract<OperatorClassItem, { kind: "operator" }> = { kind: "operator", number: number(), operator: this.operatorName() };
+      if (this.isPunct("(")) item.types = this.parenthesized();
+      if (this.accept("FOR")) {
+        if (this.accept("SEARCH")) return item;
+        if (!this.acceptSeq("ORDER", "BY")) this.fail("expected SEARCH or ORDER BY");
+        item.orderBy = this.qualifiedName("a sort operator family");
+      }
+      return item;
+    }
+    if (this.accept("FUNCTION")) {
+      const n = number();
+      const types = this.isPunct("(") ? this.parenthesized() : undefined;
+      const fn = this.qualifiedName("a function name");
+      if (!this.isPunct("(")) this.fail("expected '(' and the function's argument types");
+      return { kind: "function", number: n, ...(types ? { types } : {}), function: fn, args: this.parenthesized() };
+    }
+    if (this.accept("STORAGE")) return { kind: "storage", type: this.typeName() };
+    return this.fail("expected OPERATOR, FUNCTION or STORAGE");
+  }
+
+  private operatorClass(): OperatorClassNode {
+    const name = this.qualifiedName("an operator class name");
+    const isDefault = this.accept("DEFAULT");
+    this.expect("FOR");
+    this.expect("TYPE");
+    const type = this.typeName();
+    this.expect("USING");
+    const method = this.nameTok("an index access method").text;
+    const node: OperatorClassNode = { statement: "operatorClass", name, default: isDefault, type, method, items: [] };
+    if (this.accept("FAMILY")) node.family = this.qualifiedName("an operator family name");
+    this.expect("AS");
+    do node.items.push(this.operatorClassItem());
+    while (this.acceptPunct(","));
+    return node;
+  }
+
+  private operatorFamily(): OperatorFamilyNode {
+    const name = this.qualifiedName("an operator family name");
+    this.expect("USING");
+    return { statement: "operatorFamily", name, method: this.nameTok("an index access method").text };
+  }
+
+  /** After `CREATE TEXT SEARCH`: a dictionary or a configuration. A parser and a template are C code. */
+  private textSearch(): TextSearchDictionaryNode | TextSearchConfigurationNode {
+    if (this.accept("DICTIONARY")) {
+      const name = this.qualifiedName("a text search dictionary name");
+      const options = this.definition("a dictionary option");
+      // The options past TEMPLATE belong to the template; a name given twice is still wrong.
+      this.checkDefinition(options, options.map((o) => o.name), ["template"], "a text search dictionary");
+      return { statement: "textSearchDictionary", name, options };
+    }
+    if (this.accept("CONFIGURATION")) {
+      const name = this.qualifiedName("a text search configuration name");
+      const options = this.definition("a configuration option");
+      this.checkDefinition(options, ["parser", "copy"], [], "a text search configuration");
+      if (options.some((o) => o.name === "copy")) this.fail("expected PARSER (COPY copies mappings chant does not read; name the parser and write the mappings)", this.tokens[options.find((o) => o.name === "copy")!.nameSpan.from]);
+      if (!options.some((o) => o.name === "parser")) this.fail("expected PARSER (a configuration needs the parser that splits text into tokens)", this.lastSeen());
+      return { statement: "textSearchConfiguration", name, options };
+    }
+    return this.fail("expected DICTIONARY or CONFIGURATION (a text search parser and a text search template are C code an extension installs)");
+  }
+
+  /** `ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type [, ...] WITH dictionary [, ...]`. */
+  private textSearchMapping(): TextSearchMappingNode {
+    const name = this.qualifiedName("a text search configuration name");
+    if (!this.acceptSeq("ADD", "MAPPING")) this.fail("expected ADD MAPPING (a configuration's mappings are declared with ADD MAPPING after its CREATE)");
+    this.expect("FOR");
+    const node: TextSearchMappingNode = { statement: "textSearchMapping", name, tokens: [], dictionaries: [] };
+    do node.tokens.push((({ text, span }) => ({ name: text, span }))(this.nameTok("a token type")));
+    while (this.acceptPunct(","));
+    this.expect("WITH");
+    do node.dictionaries.push(this.qualifiedName("a text search dictionary name"));
+    while (this.acceptPunct(","));
+    return node;
+  }
+
+  /** `CREATE FOREIGN TABLE`: the column list form. A key, a generated column, INHERITS and PARTITION OF are not declared. */
+  private foreignTable(): ForeignTableNode {
+    const ifNotExists = this.ifNotExists();
+    const name = this.qualifiedName("a foreign table name");
+    if (kw(this.peek(), "PARTITION")) this.fail("expected the column list (a foreign table that is a partition, PARTITION OF, is not declared here)");
+    const node: ForeignTableNode = { statement: "foreignTable", ifNotExists, name, columns: [], constraints: [], server: { pieces: [], span: this.span(this.idx(), []) }, options: [] };
+    this.expectPunct("(");
+    if (!this.acceptPunct(")")) {
+      for (;;) {
+        if (kw(this.peek(), "LIKE")) this.fail("LIKE is not declared on a foreign table; write its columns");
+        const c = this.tableConstraint();
+        if (c) node.constraints.push(c);
+        else node.columns.push(this.column(true, true));
+        if (this.acceptPunct(",")) continue;
+        this.expectPunct(")");
+        break;
+      }
+    }
+    if (kw(this.peek(), "INHERITS")) this.fail("expected SERVER (INHERITS is not declared on a foreign table)");
+    this.expect("SERVER");
+    node.server = this.databaseName("a server name");
+    if (this.accept("OPTIONS")) node.options = this.genericOptions();
+    // A foreign table has CHECK and NOT NULL constraints and a default; Postgres refuses the rest, and a generated column is not read.
+    const bad = (c: ConstraintNode, what: string): never => this.fail(`${what} (a foreign table holds CHECK and NOT NULL constraints only; the remote server keeps the rest)`, this.tokens[c.span.from]);
+    for (const c of [...node.constraints, ...node.columns.flatMap((x) => x.constraints)]) {
+      if (c.kind !== "CHECK" && c.kind !== "NOT NULL") bad(c, `expected CHECK or NOT NULL, not ${c.kind}`);
+      if (c.notEnforced !== undefined) bad(c, "ENFORCED and NOT ENFORCED are 18's and are not declared on a foreign table");
+    }
+    for (const col of node.columns) if (col.generated) this.fail(`expected no generated column (${col.name} is GENERATED ${col.generated.kind.toUpperCase()}; a foreign table's generated columns are not declared)`, this.tokens[col.nameSpan.from]);
+    return node;
+  }
+
   private statistics(): StatisticsNode {
     const ifNotExists = this.ifNotExists();
     const name = this.qualifiedName("a statistics name");
@@ -2074,6 +2276,23 @@ class PgParser extends SqlCursor {
     } else if (this.acceptSeq("FOREIGN", "DATA", "WRAPPER")) {
       objectType = "FOREIGN DATA WRAPPER";
       target = this.qualifiedName("a foreign data wrapper name");
+    } else if (kw(this.peek(), "OPERATOR") && kw(this.peek(1), "CLASS", "FAMILY") && !this.isPunct(".", 2)) {
+      this.p++;
+      objectType = `OPERATOR ${this.next().text.toUpperCase()}`;
+      target = this.qualifiedName(`an ${objectType.toLowerCase()} name`);
+      this.expect("USING");
+      const using = this.nameTok("an index access method").text;
+      this.expect("IS");
+      const node: CommentNode = { statement: "comment", objectType, target, using };
+      if (!this.accept("NULL")) node.text = this.commentText();
+      return node;
+    } else if (this.acceptSeq("TEXT", "SEARCH")) {
+      if (!this.accept("CONFIGURATION", "DICTIONARY")) this.fail("expected CONFIGURATION or DICTIONARY");
+      objectType = `TEXT SEARCH ${this.lastSeen()!.text.toUpperCase()}`;
+      target = this.qualifiedName(`a ${objectType.toLowerCase()} name`);
+    } else if (this.acceptSeq("FOREIGN", "TABLE")) {
+      objectType = "FOREIGN TABLE";
+      target = this.qualifiedName("a foreign table name");
     } else if (this.accept("OPERATOR")) {
       objectType = "OPERATOR";
       target = this.operatorName();
@@ -2093,7 +2312,7 @@ class PgParser extends SqlCursor {
       if (this.acceptSeq("MATERIALIZED", "VIEW")) objectType = "MATERIALIZED VIEW";
       else if (this.accept("TABLE", "COLUMN", "INDEX", "VIEW", "SEQUENCE", "TYPE", "DOMAIN", "SCHEMA", "EXTENSION", "FUNCTION", "PROCEDURE")) {
         objectType = this.tokens[this.idx(-1)]!.text.toUpperCase();
-      } else return this.fail("expected TABLE, COLUMN, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, SCHEMA, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, COLLATION, CAST, OPERATOR, TRIGGER, EVENT TRIGGER, STATISTICS, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, POLICY, ROLE or CONSTRAINT");
+      } else return this.fail("expected TABLE, COLUMN, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, SCHEMA, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, COLLATION, CAST, OPERATOR, TRIGGER, EVENT TRIGGER, STATISTICS, FOREIGN TABLE, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, OPERATOR CLASS, OPERATOR FAMILY, TEXT SEARCH CONFIGURATION, TEXT SEARCH DICTIONARY, POLICY, ROLE or CONSTRAINT");
       target = this.qualifiedName("an object name");
       if ((objectType === "FUNCTION" || objectType === "PROCEDURE") && this.isPunct("(")) args = this.parenthesized();
     }

package/src/postgres/plan/deep.ts

@@ -44,6 +44,11 @@ const TAG: Record<string, (s: TemplateStringsArray) => { props: object }> = {
   [POSTGRES_ENTITY_TYPES.cast]: tags.cast,
   [POSTGRES_ENTITY_TYPES.eventTrigger]: tags.eventTrigger,
   [POSTGRES_ENTITY_TYPES.operator]: tags.operator,
+  [POSTGRES_ENTITY_TYPES.operatorClass]: tags.operatorClass,
+  [POSTGRES_ENTITY_TYPES.operatorFamily]: tags.operatorFamily,
+  [POSTGRES_ENTITY_TYPES.foreignTable]: tags.foreignTable,
+  [POSTGRES_ENTITY_TYPES.textSearchConfiguration]: tags.textSearchConfiguration,
+  [POSTGRES_ENTITY_TYPES.textSearchDictionary]: tags.textSearchDictionary,
   [POSTGRES_ENTITY_TYPES.statistics]: tags.statistics,
   [POSTGRES_ENTITY_TYPES.foreignDataWrapper]: tags.foreignDataWrapper,
   [POSTGRES_ENTITY_TYPES.foreignServer]: tags.foreignServer,
@@ -148,6 +153,12 @@ const PROP_OF_FIELD: Record<string, string[]> = {
   validator: ["validator", "validatorName", "noValidator"],
   serverType: ["serverType"],
   wrapper: ["wrapper", "wrapperName"],
+  server: ["serverName"],
+  family: ["family"],
+  items: ["items"],
+  template: ["template"],
+  parser: ["parser"],
+  mappings: ["mappings"],
   allTables: ["allTables"],
   tables: ["tables"],
   schemas: ["schemas"],
@@ -190,7 +201,7 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
     if (!fieldKeys.has(f)) for (const key of keys) if (f !== "schema" || d.kind === "extension") adopt(key);
   }
 
-  if (d.kind === "table") {
+  if (d.kind === "table" || d.kind === "foreignTable") {
     const declaredColumns = (declared.columns as unknown[] | undefined) ?? [];
     const liveColumns = (live.columns as unknown[] | undefined) ?? [];
     // Columns are matched by name and listed in the declaration's order, the
@@ -216,7 +227,7 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
       ? ["definition"]
       : d.kind === "collation"
         ? ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"]
-        : d.kind === "foreignDataWrapper" || d.kind === "foreignServer"
+        : d.kind === "foreignDataWrapper" || d.kind === "foreignServer" || d.kind === "foreignTable" || d.kind === "textSearchDictionary"
           ? ["options"]
           : d.kind === "publication"
             ? ["publish", "viaRoot", "generatedColumns"]
@@ -230,9 +241,9 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
     out.method = live.method;
     out.functionArgs = live.functionArgs;
   }
-  if (d.kind === "table" || d.kind === "domain") {
+  if (d.kind === "table" || d.kind === "domain" || d.kind === "foreignTable") {
     // A constraint the declaration says the same as the server is the declaration's (its name included or left out).
-    const kinds = d.kind === "domain" ? ["CHECK"] : Object.keys(CONSTRAINT_PROPS);
+    const kinds = d.kind === "table" ? Object.keys(CONSTRAINT_PROPS) : ["CHECK"];
     for (const kind of kinds) {
       const key = CONSTRAINT_PROPS[kind]!;
       const dl = d.constraints.filter((c) => c.kind === kind);

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", "operator", "statistics"]);
+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[]>> = {
@@ -226,14 +226,20 @@ const DEFINITION: Readonly<Record<string, readonly string[]>> = {
   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[] }>> = {
+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" },
 };
 
 /**
@@ -245,17 +251,98 @@ const ALTERED_KINDS: Readonly<Record<string, { recreate: readonly string[]; inPl
  */
 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 } = ALTERED_KINDS[after.kind]!;
+  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 was = replaced.map((k) => `${k} ${show(before.fields[k]) ?? "-"}`).join("; ");
-    const now = replaced.map((k) => `${k} ${show(after.fields[k]) ?? "-"}`).join("; ");
+    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, "SQLPG303", show(before.fields[k]), show(after.fields[k])));
+  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);
 }
 
 /**
@@ -292,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) {
@@ -421,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");