@intentius/chant-lexicon-sql 0.124.46 → 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[];
 }
@@ -271,6 +273,129 @@ export interface EventTriggerNode {
   function: NameNode;
 }
 
+/** `CREATE OPERATOR [schema.]symbol (FUNCTION = f, LEFTARG = type, RIGHTARG = type, ...)`. */
+export interface OperatorNode {
+  statement: "operator";
+  /** The schema, when written, then the operator's symbol. */
+  name: NameNode;
+  options: DefElem[];
+}
+
+/** `CREATE STATISTICS [IF NOT EXISTS] name [(kind, ...)] ON target, ... FROM table`. */
+export interface StatisticsNode {
+  statement: "statistics";
+  ifNotExists: boolean;
+  name: NameNode;
+  /** `ndistinct`, `dependencies`, `mcv`, folded; empty when the server picks them all. */
+  kinds: string[];
+  /** Each column or parenthesized expression. */
+  targets: Span[];
+  table: NameNode;
+}
+
+/** One `name 'value'` of an `OPTIONS (...)` list. */
+export interface GenericOption {
+  name: string;
+  nameSpan: Span;
+  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";
+  name: NameNode;
+  /** The handler function; `null` for `NO HANDLER`. */
+  handler?: NameNode | null;
+  /** The validator function; `null` for `NO VALIDATOR`. */
+  validator?: NameNode | null;
+  options: GenericOption[];
+}
+
+/** `CREATE SERVER [IF NOT EXISTS] name [TYPE 't'] [VERSION 'v'] FOREIGN DATA WRAPPER w [OPTIONS (...)]`. */
+export interface ForeignServerNode {
+  statement: "foreignServer";
+  ifNotExists: boolean;
+  name: NameNode;
+  type?: Span;
+  version?: Span;
+  wrapper: NameNode;
+  options: GenericOption[];
+}
+
+/** One member of a publication: a table (with its column list and row filter) or every table of a schema. */
+export type PublicationItem =
+  | { kind: "table"; table: NameNode; columns?: Array<{ name: string; span: Span }>; where?: Span }
+  | { kind: "schema"; schema: NameNode };
+
+/** `CREATE PUBLICATION name [FOR ALL TABLES | FOR TABLE ... | FOR TABLES IN SCHEMA ...] [WITH (...)]`. */
+export interface PublicationNode {
+  statement: "publication";
+  name: NameNode;
+  allTables: boolean;
+  items: PublicationItem[];
+  options: DefElem[];
+}
+
 export interface DomainNode {
   statement: "domain";
   name: NameNode;
@@ -399,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`. */
@@ -418,6 +545,17 @@ export type StatementNode =
   | CollationNode
   | CastNode
   | EventTriggerNode
+  | OperatorNode
+  | OperatorClassNode
+  | OperatorFamilyNode
+  | ForeignTableNode
+  | TextSearchDictionaryNode
+  | TextSearchConfigurationNode
+  | TextSearchMappingNode
+  | StatisticsNode
+  | ForeignDataWrapperNode
+  | ForeignServerNode
+  | PublicationNode
   | DomainNode
   | ExtensionNode
   | RoutineNode
@@ -503,6 +641,15 @@ export const AGGREGATE_OPTIONS = [
 /** `CREATE COLLATION`'s options (sql-createcollation). */
 export const COLLATION_OPTIONS = ["locale", "lc_collate", "lc_ctype", "provider", "deterministic", "rules", "version"];
 
+/** `CREATE OPERATOR`'s options (sql-createoperator); `procedure` is the old spelling of `function`. */
+export const OPERATOR_OPTIONS = ["function", "procedure", "leftarg", "rightarg", "commutator", "negator", "restrict", "join", "hashes", "merges"];
+
+/** `CREATE STATISTICS`'s kinds (sql-createstatistics). */
+export const STATISTICS_KINDS = ["ndistinct", "dependencies", "mcv"];
+
+/** `CREATE PUBLICATION ... WITH (...)`'s options (sql-createpublication); `publish_generated_columns` is 18's. */
+export const PUBLICATION_OPTIONS = ["publish", "publish_via_partition_root", "publish_generated_columns"];
+
 /** What may follow `IS` inside a `b_expr`. */
 const B_EXPR_IS = [["DISTINCT", "FROM"], ["NOT", "DISTINCT", "FROM"], ["DOCUMENT"], ["NOT", "DOCUMENT"]];
 
@@ -768,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");
@@ -777,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;
@@ -993,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");
@@ -1012,6 +1163,24 @@ 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")) {
+        // 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();
       if (kw(this.peek(), "UNIQUE", "INDEX")) return this.index();
     }
     const persistence = this.persistence();
@@ -1021,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, 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 {
@@ -1239,6 +1408,260 @@ class PgParser extends SqlCursor {
     return node;
   }
 
+  /** An unqualified, database-wide object's name (a wrapper, a server, a publication). */
+  private databaseName(what: string): NameNode {
+    const { text, span } = this.nameTok(what);
+    if (this.isPunct(".")) this.fail(`expected ${what} without a schema (it belongs to the database)`);
+    return { pieces: [text], span };
+  }
+
+  /** `( name 'value' [, ...] )`: a foreign data wrapper's or server's options. */
+  private genericOptions(): GenericOption[] {
+    this.expectPunct("(");
+    const out: GenericOption[] = [];
+    const seen = new Set<string>();
+    for (;;) {
+      const t = this.next();
+      if (t.kind !== "ident" && t.kind !== "qident") this.fail("expected an option name", t);
+      const nameSpan = this.span(this.idx(-1), []);
+      const name = identValue(t);
+      if (seen.has(name)) this.fail(`${name} is given twice`, t);
+      seen.add(name);
+      const v = this.next();
+      if (v.kind !== "string" && v.kind !== "ref") this.fail("expected the option's value, a string", v);
+      out.push({ name, nameSpan, value: this.span(this.idx(-1), v.kind === "ref" ? [v.part] : []) });
+      if (this.acceptPunct(",")) continue;
+      this.expectPunct(")");
+      return out;
+    }
+  }
+
+  /** `[schema.]symbol`: an operator's name, its symbol made of operator characters. */
+  private operatorName(): NameNode {
+    const from = this.idx();
+    const refs: number[] = [];
+    const pieces: string[] = [];
+    const symbol = (): void => {
+      const t = this.next();
+      if (t.kind !== "op") this.fail("expected the operator's symbol (operator characters, such as ===)", t);
+      pieces.push(t.text);
+    };
+    if (this.peek()?.kind === "op") symbol();
+    else {
+      const t = this.next();
+      this.colId(t, "a schema name");
+      if (t.kind === "ref") refs.push(t.part);
+      pieces.push(t.kind === "ref" ? "" : identValue(t));
+      this.expectPunct(".");
+      symbol();
+    }
+    return { pieces, span: this.span(from, refs) };
+  }
+
+  private operator(): OperatorNode {
+    const name = this.operatorName();
+    const options = this.definition("an operator option");
+    this.checkDefinition(options, OPERATOR_OPTIONS, [], "an operator");
+    if (!options.some((o) => o.name === "function" || o.name === "procedure")) this.fail("expected FUNCTION (an operator needs the function it calls)", this.lastSeen());
+    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");
+    const kinds: string[] = [];
+    if (this.isPunct("(")) {
+      for (const k of this.nameList("a statistics kind")) {
+        if (!STATISTICS_KINDS.includes(k.name)) this.fail(`expected a statistics kind (${STATISTICS_KINDS.join(", ")})`, this.tokens[k.span.from]);
+        kinds.push(k.name);
+      }
+    }
+    this.expect("ON");
+    const targets: Span[] = [];
+    do targets.push(this.expr(["FROM"]));
+    while (this.acceptPunct(","));
+    this.expect("FROM");
+    const table = this.qualifiedName("a table name");
+    return { statement: "statistics", ifNotExists, name, kinds, targets, table };
+  }
+
+  private foreignDataWrapper(): ForeignDataWrapperNode {
+    const node: ForeignDataWrapperNode = { statement: "foreignDataWrapper", name: this.databaseName("a foreign data wrapper name"), options: [] };
+    for (;;) {
+      if (this.accept("HANDLER")) node.handler = this.qualifiedName("a handler function");
+      else if (this.acceptSeq("NO", "HANDLER")) node.handler = null;
+      else if (this.accept("VALIDATOR")) node.validator = this.qualifiedName("a validator function");
+      else if (this.acceptSeq("NO", "VALIDATOR")) node.validator = null;
+      else if (this.accept("OPTIONS")) node.options = this.genericOptions();
+      else return node;
+    }
+  }
+
+  private foreignServer(): ForeignServerNode {
+    const ifNotExists = this.ifNotExists();
+    const name = this.databaseName("a server name");
+    const node: Partial<ForeignServerNode> & { statement: "foreignServer" } = { statement: "foreignServer", ifNotExists, name, options: [] };
+    const string = (what: string): Span => {
+      const t = this.next();
+      if (t.kind !== "string" && t.kind !== "ref") this.fail(`expected ${what} as a string`, t);
+      return this.span(this.idx(-1), t.kind === "ref" ? [t.part] : []);
+    };
+    if (this.accept("TYPE")) node.type = string("the server type");
+    if (this.accept("VERSION")) node.version = string("the server version");
+    if (!this.acceptSeq("FOREIGN", "DATA", "WRAPPER")) this.fail("expected FOREIGN DATA WRAPPER (a server names the wrapper it is for)");
+    node.wrapper = this.qualifiedName("a foreign data wrapper name");
+    if (this.accept("OPTIONS")) node.options = this.genericOptions();
+    return node as ForeignServerNode;
+  }
+
+  private publication(): PublicationNode {
+    const node: PublicationNode = { statement: "publication", name: this.databaseName("a publication name"), allTables: false, items: [], options: [] };
+    if (this.accept("FOR")) {
+      if (this.acceptSeq("ALL", "TABLES")) node.allTables = true;
+      else {
+        let mode: "table" | "schema" | undefined;
+        do {
+          if (this.accept("TABLE")) mode = "table";
+          else if (this.acceptSeq("TABLES", "IN", "SCHEMA")) mode = "schema";
+          else if (mode === undefined) this.fail("expected ALL TABLES, TABLE or TABLES IN SCHEMA");
+          if (mode === "schema") {
+            node.items.push({ kind: "schema", schema: this.qualifiedName("a schema name") });
+            continue;
+          }
+          this.accept("ONLY");
+          const table = this.qualifiedName("a table name");
+          if (this.isOp("*")) this.p++;
+          const item: PublicationItem = { kind: "table", table };
+          if (this.isPunct("(")) item.columns = this.nameList("a column name");
+          if (this.accept("WHERE")) item.where = this.checkedParens();
+          node.items.push(item);
+        } while (this.acceptPunct(","));
+      }
+    }
+    if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+      this.p++;
+      node.options = this.definition("a publication option");
+      this.checkDefinition(node.options, PUBLICATION_OPTIONS, [], "a publication");
+    }
+    return node;
+  }
+
   private table(persistence: TableNode["persistence"]): TableNode {
     const ifNotExists = this.ifNotExists();
     const node: TableNode = { statement: "table", persistence, ifNotExists, name: this.qualifiedName("a table name"), columns: [], constraints: [], like: [] };
@@ -1850,6 +2273,34 @@ class PgParser extends SqlCursor {
       const node: CommentNode = { statement: "comment", objectType, target, cast: { source, target: castTarget } };
       if (!this.accept("NULL")) node.text = this.commentText();
       return node;
+    } 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();
+      if (!this.isPunct("(")) this.fail("expected '(' and the operator's operand types");
+      args = this.parenthesized();
+    } else if (this.accept("SERVER", "PUBLICATION", "STATISTICS")) {
+      objectType = this.lastSeen()!.text.toUpperCase();
+      target = this.qualifiedName(`a ${objectType.toLowerCase()} name`);
     } else if (this.accept("AGGREGATE", "COLLATION")) {
       objectType = this.lastSeen()!.text.toUpperCase();
       target = this.qualifiedName(`an ${objectType.toLowerCase()} name`);
@@ -1861,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, TRIGGER, EVENT TRIGGER, 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

@@ -43,6 +43,16 @@ const TAG: Record<string, (s: TemplateStringsArray) => { props: object }> = {
   [POSTGRES_ENTITY_TYPES.collation]: tags.collation,
   [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,
+  [POSTGRES_ENTITY_TYPES.publication]: tags.publication,
   [POSTGRES_ENTITY_TYPES.extension]: tags.extension,
   [POSTGRES_ENTITY_TYPES.function]: tags.func,
   [POSTGRES_ENTITY_TYPES.procedure]: tags.procedure,
@@ -137,6 +147,24 @@ const PROP_OF_FIELD: Record<string, string[]> = {
   context: ["context"],
   event: ["event"],
   tags: ["tags"],
+  targets: ["targets"],
+  kinds: ["kinds"],
+  handler: ["handler", "handlerName", "noHandler"],
+  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"],
+  publish: [],
+  viaRoot: [],
+  generatedColumns: [],
 };
 
 /** Props keys that hold constraints, by constraint kind. */
@@ -159,6 +187,7 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
   if (d.schema === l.schema) adopt("schema");
   // An aggregate's argument types and a cast's two types are its identity: the same, they are the declaration's.
   if (d.kind === "aggregate" && d.signature === l.signature) for (const key of ["args", "orderBy"]) adopt(key);
+  if (d.kind === "operator" && d.signature === l.signature) for (const key of ["leftArg", "rightArg"]) adopt(key);
   if (d.kind === "cast" && d.name === l.name) for (const key of ["sourceType", "targetType"]) adopt(key);
 
   const fieldKeys = new Set([...Object.keys(d.fields), ...Object.keys(l.fields)]);
@@ -172,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
@@ -193,7 +222,16 @@ export function inDeclaredVocabulary(declared: Props, live: Props, d: CanonicalP
     ].map((c) => c.value);
   }
   // An aggregate's or a collation's `options` is the declaration's only when every field read from it is the same (a role's `options` shares the key).
-  const optionFields = d.kind === "aggregate" ? ["definition"] : d.kind === "collation" ? ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"] : undefined;
+  const optionFields =
+    d.kind === "aggregate" || d.kind === "operator"
+      ? ["definition"]
+      : d.kind === "collation"
+        ? ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"]
+        : d.kind === "foreignDataWrapper" || d.kind === "foreignServer" || d.kind === "foreignTable" || d.kind === "textSearchDictionary"
+          ? ["options"]
+          : d.kind === "publication"
+            ? ["publish", "viaRoot", "generatedColumns"]
+            : undefined;
   if (optionFields) {
     if (optionFields.every((f) => JSON.stringify(d.fields[f]) === JSON.stringify(l.fields[f]))) adopt("options");
     else out.options = live.options;
@@ -203,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);