@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/postgres/entities.ts

@@ -2,7 +2,8 @@
  * The Postgres entities: `schema`, `table`, `index`, `view`, `sequence`,
  * `type` (enum, composite and range), `domain`, `extension`, `func`,
  * `procedure`, `aggregate`, `trigger`, `eventTrigger`, `collation`, `cast`,
- * `policy`, `role` and `grant` tagged templates that parse their DDL at fold
+ * `operatorClass`, `operatorFamily`, `foreignTable`, `textSearchConfiguration`,
+ * `textSearchDictionary`, `policy`, `role` and `grant` tagged templates that parse their DDL at fold
  * time into one Declarable each (chant #3278, #3279, #3680, #3681, #3911).
  *
  * ```ts
@@ -57,7 +58,7 @@
 import type { AttrRef } from "@intentius/chant/attrref";
 import { setInterpolationFields } from "@intentius/chant/provenance";
 import { isTrivia, POSTGRES_LEXICAL, SqlSyntaxError, untokenize, type Token } from "./tokens";
-import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type DefElem, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
+import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type DefElem, type GenericOption, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode, type TextSearchMappingNode } from "./parser";
 import { keywordCategory, quoteIdent } from "./keywords";
 import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, unparsedClauses, type TemplateCtx, type TemplateDialect, type UnparsedClause } from "../core/interpolation";
 import { SqlObject, isColumnRefOf, isSqlObjectOf, makeSqlEntity } from "../core/entity";
@@ -74,6 +75,7 @@ export type { AnyColumn, Column, ColumnTraits, KeyColumn, Named, NotNullColumn,
 
 export { POSTGRES_ENTITY_TYPES, type PostgresEntityType } from "./entity-types";
 import { POSTGRES_ENTITY_TYPES, type PostgresEntityType } from "./entity-types";
+import { isSecretOption } from "./secret-options";
 
 // ── Values ─────────────────────────────────────────────────────────────
 
@@ -92,6 +94,8 @@ export interface ColumnDef {
   collate?: string;
   compression?: string;
   storage?: string;
+  /** A foreign table column's `OPTIONS (...)`: each option by its name to its string value. */
+  options?: Record<string, string>;
   comment?: string;
 }
 
@@ -341,6 +345,141 @@ export interface EventTriggerProps extends Omit<CommonProps, "schema"> {
   functionName: string;
 }
 
+export interface OperatorProps extends CommonProps {
+  /** `LEFTARG`, as written; absent for a prefix operator. */
+  leftArg?: string;
+  /** `RIGHTARG`, as written; absent for a postfix operator (removed in 14, so for none the server still holds). */
+  rightArg?: string;
+  /**
+   * The rest of the definition by option name, folded (`function`,
+   * `commutator`, `restrict`), to its value as written; `hashes` and `merges`
+   * to `true`. `procedure`, the old spelling, is `function`.
+   */
+  options: Record<string, string>;
+}
+
+/** One member of an operator class, as written. */
+export type OperatorClassItemDef =
+  | {
+      kind: "operator";
+      number: string;
+      /** The operator, `schema.symbol` or a bare symbol. */
+      operator: string;
+      /** `(left, right)` as written, parentheses excluded; absent when both are the class's type. */
+      types?: string;
+      /** `FOR ORDER BY`'s btree operator family; absent for `FOR SEARCH`, the default. */
+      orderBy?: string;
+    }
+  | { kind: "function"; number: string; types?: string; function: string; args: string }
+  | { kind: "storage"; type: string };
+
+/** `CREATE OPERATOR CLASS`: the operators and support functions an index access method uses for a data type. */
+export interface OperatorClassProps extends CommonProps {
+  default?: boolean;
+  /** `FOR TYPE`, as written. Not `type`: a serialized object has that key for its entity type. */
+  dataType: string;
+  /** `USING`: the index access method, folded. */
+  method: string;
+  /** `FAMILY`, as written; absent when the class is in a family of its own name. */
+  family?: string;
+  items: OperatorClassItemDef[];
+}
+
+/** `CREATE OPERATOR FAMILY`: a set of operator classes that work together; members arrive with the classes. */
+export interface OperatorFamilyProps extends CommonProps {
+  /** `USING`: the index access method, folded. */
+  method: string;
+}
+
+/** `CREATE FOREIGN TABLE`: a table whose rows are on a foreign server. */
+export interface ForeignTableProps extends CommonProps {
+  ifNotExists?: boolean;
+  columns: ColumnDef[];
+  checks: CheckDef[];
+  /** `SERVER`: the foreign server's SQL name. */
+  serverName: string;
+  /** `OPTIONS (...)`: each option by its name to its string value. */
+  options: Record<string, string>;
+}
+
+/** `CREATE TEXT SEARCH DICTIONARY`: a template with its options. */
+export interface TextSearchDictionaryProps extends CommonProps {
+  /** `TEMPLATE`, as written. */
+  template: string;
+  /** The template's options by name, folded, to their value as written. */
+  options: Record<string, string>;
+}
+
+/** One `ADD MAPPING FOR tokens WITH dictionaries` of a text search configuration. */
+export interface TextSearchMappingDef {
+  /** The token types, folded. */
+  tokens: string[];
+  /** The dictionaries in the order they are consulted, as written. */
+  dictionaries: string[];
+}
+
+/** `CREATE TEXT SEARCH CONFIGURATION`: a parser and what each token type it finds is mapped to. */
+export interface TextSearchConfigurationProps extends CommonProps {
+  /** `PARSER`, as written. */
+  parser: string;
+  mappings: TextSearchMappingDef[];
+}
+
+/** `CREATE STATISTICS`: extended statistics on columns or expressions of one table. */
+export interface StatisticsProps extends CommonProps {
+  ifNotExists?: boolean;
+  /** `ndistinct`, `dependencies`, `mcv`, folded; absent when the server computes all three. */
+  kinds?: string[];
+  /** Each column or expression, as written. */
+  targets: string[];
+  /** The table: the entity when interpolated, else its name. */
+  table: PostgresObject | string;
+  /** The table's SQL name. */
+  tableName: string;
+}
+
+export interface ForeignDataWrapperProps extends Omit<CommonProps, "schema"> {
+  /** The handler function: the entity when interpolated, else its name. */
+  handler?: PostgresObject | string;
+  handlerName?: string;
+  /** `NO HANDLER`, written out. */
+  noHandler?: boolean;
+  validator?: PostgresObject | string;
+  validatorName?: string;
+  noValidator?: boolean;
+  /** `OPTIONS (...)`: each option by its name to its string value. */
+  options: Record<string, string>;
+}
+
+export interface ForeignServerProps extends Omit<CommonProps, "schema"> {
+  ifNotExists?: boolean;
+  serverType?: string;
+  version?: string;
+  /** The wrapper: the entity when interpolated, else its name. */
+  wrapper: PostgresObject | string;
+  wrapperName: string;
+  options: Record<string, string>;
+}
+
+/** A table of a publication, with the column list and row filter it is published with. */
+export interface PublicationTableDef {
+  /** The table: the entity when interpolated, else its name. */
+  table: PostgresObject | string;
+  tableName: string;
+  columns?: string[];
+  /** The row filter, as written with its parentheses. */
+  where?: string;
+}
+
+export interface PublicationProps extends Omit<CommonProps, "schema"> {
+  allTables?: boolean;
+  tables: PublicationTableDef[];
+  /** `TABLES IN SCHEMA`: the schema's SQL name, an interpolated schema by its name. */
+  schemas: string[];
+  /** `WITH (...)`: each option by its name to its value as written. */
+  options: Record<string, string>;
+}
+
 export interface DomainProps extends CommonProps {
   /** The underlying data type. */
   dataType: string;
@@ -607,6 +746,56 @@ export interface PostgresEventTrigger extends PostgresObject {
   readonly props: EventTriggerProps;
 }
 
+export interface PostgresOperator extends PostgresObject {
+  readonly entityType: "Postgres::Operator";
+  readonly props: OperatorProps;
+}
+
+export interface PostgresOperatorClass extends PostgresObject {
+  readonly entityType: "Postgres::OperatorClass";
+  readonly props: OperatorClassProps;
+}
+
+export interface PostgresOperatorFamily extends PostgresObject {
+  readonly entityType: "Postgres::OperatorFamily";
+  readonly props: OperatorFamilyProps;
+}
+
+export interface PostgresForeignTable extends PostgresObject {
+  readonly entityType: "Postgres::ForeignTable";
+  readonly props: ForeignTableProps;
+}
+
+export interface PostgresTextSearchDictionary extends PostgresObject {
+  readonly entityType: "Postgres::TextSearchDictionary";
+  readonly props: TextSearchDictionaryProps;
+}
+
+export interface PostgresTextSearchConfiguration extends PostgresObject {
+  readonly entityType: "Postgres::TextSearchConfiguration";
+  readonly props: TextSearchConfigurationProps;
+}
+
+export interface PostgresStatistics extends PostgresObject {
+  readonly entityType: "Postgres::Statistics";
+  readonly props: StatisticsProps;
+}
+
+export interface PostgresForeignDataWrapper extends PostgresObject {
+  readonly entityType: "Postgres::ForeignDataWrapper";
+  readonly props: ForeignDataWrapperProps;
+}
+
+export interface PostgresForeignServer extends PostgresObject {
+  readonly entityType: "Postgres::ForeignServer";
+  readonly props: ForeignServerProps;
+}
+
+export interface PostgresPublication extends PostgresObject {
+  readonly entityType: "Postgres::Publication";
+  readonly props: PublicationProps;
+}
+
 export interface PostgresExtension extends PostgresObject {
   readonly entityType: "Postgres::Extension";
   readonly props: ExtensionProps;
@@ -765,6 +954,16 @@ export type PostgresTag =
   | "aggregate"
   | "trigger"
   | "eventTrigger"
+  | "operator"
+  | "operatorClass"
+  | "operatorFamily"
+  | "foreignTable"
+  | "textSearchConfiguration"
+  | "textSearchDictionary"
+  | "statistics"
+  | "foreignDataWrapper"
+  | "foreignServer"
+  | "publication"
   | "collation"
   | "cast"
   | "policy"
@@ -786,6 +985,16 @@ export const STATEMENTS_OF: Record<PostgresTag, readonly StatementNode["statemen
   aggregate: ["aggregate"],
   trigger: ["trigger"],
   eventTrigger: ["eventTrigger"],
+  operator: ["operator"],
+  operatorClass: ["operatorClass"],
+  operatorFamily: ["operatorFamily"],
+  foreignTable: ["foreignTable"],
+  textSearchConfiguration: ["textSearchConfiguration"],
+  textSearchDictionary: ["textSearchDictionary"],
+  statistics: ["statistics"],
+  foreignDataWrapper: ["foreignDataWrapper"],
+  foreignServer: ["foreignServer"],
+  publication: ["publication"],
   collation: ["collation"],
   cast: ["cast"],
   policy: ["policy"],
@@ -809,6 +1018,17 @@ const TAG_OF: Record<StatementNode["statement"], PostgresTag | undefined> = {
   aggregate: "aggregate",
   trigger: "trigger",
   eventTrigger: "eventTrigger",
+  operator: "operator",
+  operatorClass: "operatorClass",
+  operatorFamily: "operatorFamily",
+  foreignTable: "foreignTable",
+  textSearchConfiguration: "textSearchConfiguration",
+  textSearchDictionary: "textSearchDictionary",
+  textSearchMapping: undefined,
+  statistics: "statistics",
+  foreignDataWrapper: "foreignDataWrapper",
+  foreignServer: "foreignServer",
+  publication: "publication",
   collation: "collation",
   cast: "cast",
   policy: "policy",
@@ -835,6 +1055,17 @@ export const STATEMENT_NAMES: Record<StatementNode["statement"], string> = {
   aggregate: "CREATE AGGREGATE",
   trigger: "CREATE TRIGGER",
   eventTrigger: "CREATE EVENT TRIGGER",
+  operator: "CREATE OPERATOR",
+  operatorClass: "CREATE OPERATOR CLASS",
+  operatorFamily: "CREATE OPERATOR FAMILY",
+  foreignTable: "CREATE FOREIGN TABLE",
+  textSearchConfiguration: "CREATE TEXT SEARCH CONFIGURATION",
+  textSearchDictionary: "CREATE TEXT SEARCH DICTIONARY",
+  textSearchMapping: "ALTER TEXT SEARCH CONFIGURATION",
+  statistics: "CREATE STATISTICS",
+  foreignDataWrapper: "CREATE FOREIGN DATA WRAPPER",
+  foreignServer: "CREATE SERVER",
+  publication: "CREATE PUBLICATION",
   collation: "CREATE COLLATION",
   cast: "CREATE CAST",
   policy: "CREATE POLICY",
@@ -871,6 +1102,24 @@ function definitionValues(ctx: Ctx, elems: readonly DefElem[], path: string): Re
   return out;
 }
 
+/** A database-wide object's name (a wrapper, a server, a publication): one piece, or an interpolated object's name. */
+function databaseObjectName(ctx: Ctx, n: NameNode): string {
+  feed(ctx, n.span, "name");
+  return n.pieces[0] || identValue(req(text(ctx, n.span)));
+}
+
+/** An `OPTIONS (...)` list's values by option name, each a string constant's value. */
+function genericOptionValues(tag: PostgresTag, ctx: Ctx, options: readonly GenericOption[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const o of options) {
+    if (isSecretOption(o.name)) {
+      throw new SqlTemplateError(tag, `the option ${o.name} holds a credential, which the environment supplies (a user mapping, or its secret store); a declaration never carries one`, 0, 0);
+    }
+    out[o.name] = req(stringValue(text(ctx, o.value, "options")));
+  }
+  return out;
+}
+
 /** A qualified name's schema and name. An interpolated schema names the schema; an interpolated object gives both. */
 function qualified(ctx: Ctx, n: NameNode): { schema?: string; name: string } {
   const pieces: string[] = [];
@@ -929,7 +1178,7 @@ function columnName(ctx: Ctx, c: { name: string; span: Span }): string {
   return isColumnRef(v) ? v.attribute : req(text(ctx, c.span));
 }
 
-function columnDef(ctx: Ctx, c: ColumnNode): ColumnDef {
+function columnDef(ctx: Ctx, c: ColumnNode, tag: PostgresTag = "table"): ColumnDef {
   for (const span of [c.nameSpan, c.type, c.default, c.collate, c.compression, c.storage, c.generated?.expr, c.generated?.options]) feed(ctx, span, "columns");
   const def: ColumnDef = { name: columnName(ctx, { name: c.name, span: c.nameSpan }) };
   const set = <K extends keyof ColumnDef>(k: K, v: ColumnDef[K] | undefined) => {
@@ -952,6 +1201,7 @@ function columnDef(ctx: Ctx, c: ColumnNode): ColumnDef {
   set("collate", text(ctx, c.collate));
   set("compression", text(ctx, c.compression));
   set("storage", text(ctx, c.storage));
+  if (c.options && c.options.length > 0) def.options = genericOptionValues(tag, ctx, c.options);
   return def;
 }
 
@@ -1050,6 +1300,7 @@ function applyComments(
   self: { schema?: string; name: string },
   objectTypes: readonly string[],
   parts: { columns?: Map<string, Commentable>; constraints?: Map<string, Commentable>; columnComments?: Record<string, string> } = {},
+  using?: string,
 ): string | undefined {
   let comment: string | undefined;
   const isSelf = (q: { schema?: string; name: string }) => q.name === self.name && (q.schema === undefined || self.schema === undefined || q.schema === self.schema);
@@ -1091,6 +1342,8 @@ function applyComments(
         // `COMMENT ON TRIGGER name ON table`: the name is the trigger's, the table its own.
         if (qualified(ctx, c.target).name !== self.name || !c.on || !isSelf({ ...qualified(ctx, c.on), name: self.name })) refuse(c, `names another ${c.objectType.toLowerCase()} than ${self.name}`);
       } else if (!isSelf(qualified(ctx, c.target))) refuse(c, `names another object than ${sqlNameOf(self)}`);
+      // An operator class or family is named by its index method too.
+      if (using !== undefined && c.using !== using) refuse(c, `names another index method than ${using}`);
       comment = value;
     }
   }
@@ -1114,7 +1367,7 @@ function lastDot(ctx: Ctx, span: Span): number {
  */
 export function followOnStray(tag: PostgresTag, rest: readonly StatementNode[]): StatementNode | undefined {
   if (tag === "grant") return rest[0];
-  return rest.find((n) => n.statement !== "comment" && !(tag === "table" && n.statement === "rowSecurity"));
+  return rest.find((n) => n.statement !== "comment" && !(tag === "table" && n.statement === "rowSecurity") && !(tag === "textSearchConfiguration" && n.statement === "textSearchMapping"));
 }
 
 /**
@@ -1331,7 +1584,7 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
   if (stray) {
     throw new SqlTemplateError(
       tag,
-      `holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it${tag === "table" ? " and ALTER TABLE ... ROW LEVEL SECURITY" : ""}`,
+      `holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it${tag === "table" ? " and ALTER TABLE ... ROW LEVEL SECURITY" : tag === "textSearchConfiguration" ? " and ALTER TEXT SEARCH CONFIGURATION ... ADD MAPPING" : ""}`,
       0,
       0,
     );
@@ -1493,6 +1746,203 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
       );
       return make(POSTGRES_ENTITY_TYPES.eventTrigger, { name }, props);
     }
+    case "operator": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["OPERATOR"]);
+      const opt = definitionValues(ctx, node.options, "options");
+      const { leftarg, rightarg, procedure, ...rest } = opt;
+      const props: OperatorProps = stripUnset({ ...q, leftArg: leftarg, rightArg: rightarg, options: { ...rest, function: opt.function ?? procedure }, comment, ddl, source });
+      // The symbol is unquoted wherever the operator is named: `app.===`.
+      return make(POSTGRES_ENTITY_TYPES.operator, q, props, undefined, q.schema ? `${quoteIdent(q.schema)}.${q.name}` : q.name);
+    }
+    case "operatorClass": {
+      const q = qualified(ctx, node.name);
+      if (node.method === "") throw new SqlTemplateError(tag, "the index method is written out, not interpolated", 0, 0);
+      const comment = applyComments(tag, ctx, comments, q, ["OPERATOR CLASS"], {}, node.method);
+      const items = node.items.map((i): OperatorClassItemDef => {
+        if (i.kind === "storage") return { kind: "storage", type: req(text(ctx, i.type, "items")) };
+        if (i.kind === "function") {
+          feed(ctx, i.function.span, "items");
+          return stripUnset({ kind: "function", number: req(text(ctx, i.number, "items")), types: text(ctx, i.types, "items"), function: targetName(ctx, i.function), args: text(ctx, i.args, "items") ?? "" }) as OperatorClassItemDef;
+        }
+        return stripUnset({
+          kind: "operator",
+          number: req(text(ctx, i.number, "items")),
+          operator: req(text(ctx, i.operator.span, "items")),
+          types: text(ctx, i.types, "items"),
+          orderBy: i.orderBy ? targetName(ctx, i.orderBy) : undefined,
+        }) as OperatorClassItemDef;
+      });
+      const props: OperatorClassProps = stripUnset({
+        ...q,
+        default: node.default || undefined,
+        dataType: req(text(ctx, node.type, "dataType")),
+        method: node.method,
+        family: node.family ? targetName(ctx, node.family) : undefined,
+        items,
+        comment,
+        ddl,
+        source,
+      });
+      return make(POSTGRES_ENTITY_TYPES.operatorClass, q, props);
+    }
+    case "operatorFamily": {
+      const q = qualified(ctx, node.name);
+      if (node.method === "") throw new SqlTemplateError(tag, "the index method is written out, not interpolated", 0, 0);
+      const comment = applyComments(tag, ctx, comments, q, ["OPERATOR FAMILY"], {}, node.method);
+      const props: OperatorFamilyProps = stripUnset({ ...q, method: node.method, comment, ddl, source });
+      return make(POSTGRES_ENTITY_TYPES.operatorFamily, q, props);
+    }
+    case "foreignTable": {
+      const q = qualified(ctx, node.name);
+      const columns = node.columns.map((c) => columnDef(ctx, c, tag));
+      const checks: CheckDef[] = [];
+      const file = (c: ConstraintNode, cols: string[]) => {
+        if (c.kind === "CHECK") checks.push(checkDef(ctx, c));
+        else if (c.kind === "NOT NULL") {
+          const col = columns.find((x) => x.name === cols[0]);
+          if (!col) throw new SqlTemplateError(tag, `NOT NULL ${cols[0]} names no column of ${sqlNameOf(q)}`, 0, 0);
+          col.notNull = true;
+          if (c.name) col.notNullName = c.name;
+        }
+      };
+      node.columns.forEach((c, i) => c.constraints.forEach((k) => file(k, [columns[i]!.name])));
+      node.constraints.forEach((k) => file(k, k.columns.map((x) => columnName(ctx, x))));
+      const named = new Map<string, Commentable>();
+      for (const c of checks) if (c.name) named.set(c.name, c);
+      const comment = applyComments(tag, ctx, comments, q, ["FOREIGN TABLE"], { columns: new Map(columns.map((c) => [c.name, c])), constraints: named });
+      const props: ForeignTableProps = strip(
+        {
+          ...q,
+          ifNotExists: node.ifNotExists || undefined,
+          columns,
+          checks,
+          serverName: databaseObjectName(ctx, node.server),
+          options: genericOptionValues(tag, ctx, node.options),
+          comment,
+          ddl,
+          source,
+        },
+        ["columns", "checks", "options"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.foreignTable, q, props, columns.map((c) => c.name));
+    }
+    case "textSearchDictionary": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TEXT SEARCH DICTIONARY"]);
+      const { template, ...options } = definitionValues(ctx, node.options, "options");
+      const props: TextSearchDictionaryProps = strip({ ...q, template: req(template), options, comment, ddl, source }, ["options"]);
+      return make(POSTGRES_ENTITY_TYPES.textSearchDictionary, q, props);
+    }
+    case "textSearchConfiguration": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TEXT SEARCH CONFIGURATION"]);
+      const opt = definitionValues(ctx, node.options, "options");
+      const seen = new Set<string>();
+      const mappings = rest
+        .filter((n): n is TextSearchMappingNode => n.statement === "textSearchMapping")
+        .map((m): TextSearchMappingDef => {
+          feed(ctx, m.name.span, "mappings");
+          const t = qualified(ctx, m.name);
+          if (t.name !== q.name || (t.schema !== undefined && q.schema !== undefined && t.schema !== q.schema)) {
+            throw new SqlTemplateError(tag, `ADD MAPPING names another configuration (${sqlNameOf(t)}) than ${sqlNameOf(q)}`, 0, 0);
+          }
+          const tokens = m.tokens.map((x) => x.name || identValue(req(text(ctx, x.span, "mappings"))));
+          for (const tok of tokens) {
+            if (seen.has(tok)) throw new SqlTemplateError(tag, `the token type ${tok} is mapped twice in ${sqlNameOf(q)}`, 0, 0);
+            seen.add(tok);
+          }
+          for (const d of m.dictionaries) feed(ctx, d.span, "mappings");
+          return { tokens, dictionaries: m.dictionaries.map((d) => sqlNameOf(qualified(ctx, d))) };
+        });
+      const props: TextSearchConfigurationProps = strip({ ...q, parser: req(opt.parser), mappings, comment, ddl, source }, ["mappings"]);
+      return make(POSTGRES_ENTITY_TYPES.textSearchConfiguration, q, props);
+    }
+    case "textSearchMapping":
+      // Only a configuration's follow-on statement (`followOnStray`); first in a template it is refused above.
+      throw new SqlTemplateError(tag, "holds an ALTER TEXT SEARCH CONFIGURATION before any CREATE", 0, 0);
+    case "statistics": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["STATISTICS"]);
+      const props: StatisticsProps = strip(
+        {
+          ...q,
+          ifNotExists: node.ifNotExists || undefined,
+          kinds: node.kinds.length > 0 ? node.kinds : undefined,
+          targets: node.targets.map((t) => req(text(ctx, t, "targets"))),
+          table: target(ctx, node.table),
+          tableName: sqlNameOf(qualified(ctx, node.table)),
+          comment,
+          ddl,
+          source,
+        },
+        ["targets"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.statistics, q, props);
+    }
+    case "foreignDataWrapper": {
+      const name = databaseObjectName(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, { name }, ["FOREIGN DATA WRAPPER"]);
+      const props: ForeignDataWrapperProps = strip(
+        {
+          name,
+          handler: node.handler ? target(ctx, node.handler) : undefined,
+          handlerName: node.handler ? targetName(ctx, node.handler) : undefined,
+          noHandler: node.handler === null ? true : undefined,
+          validator: node.validator ? target(ctx, node.validator) : undefined,
+          validatorName: node.validator ? targetName(ctx, node.validator) : undefined,
+          noValidator: node.validator === null ? true : undefined,
+          options: genericOptionValues(tag, ctx, node.options),
+          comment,
+          ddl,
+          source,
+        },
+        ["options"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.foreignDataWrapper, { name }, props);
+    }
+    case "foreignServer": {
+      const name = databaseObjectName(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, { name }, ["SERVER"]);
+      const props: ForeignServerProps = strip(
+        {
+          name,
+          ifNotExists: node.ifNotExists || undefined,
+          serverType: node.type ? stringValue(text(ctx, node.type, "serverType")) : undefined,
+          version: node.version ? stringValue(text(ctx, node.version, "version")) : undefined,
+          wrapper: target(ctx, node.wrapper),
+          wrapperName: targetName(ctx, node.wrapper),
+          options: genericOptionValues(tag, ctx, node.options),
+          comment,
+          ddl,
+          source,
+        },
+        ["options"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.foreignServer, { name }, props);
+    }
+    case "publication": {
+      const name = databaseObjectName(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, { name }, ["PUBLICATION"]);
+      const tables = node.items.flatMap((i) =>
+        i.kind !== "table"
+          ? []
+          : [
+              stripUnset({
+                table: target(ctx, i.table),
+                tableName: sqlNameOf(qualified(ctx, i.table)),
+                columns: i.columns?.map((c) => columnName(ctx, { name: c.name, span: c.span })),
+                where: text(ctx, i.where, "tables"),
+              }) as PublicationTableDef,
+            ],
+      );
+      const schemas = node.items.flatMap((i) => (i.kind === "schema" ? [qualified(ctx, i.schema).name] : []));
+      const props: PublicationProps = strip(
+        { name, allTables: node.allTables || undefined, tables, schemas, options: definitionValues(ctx, node.options, "options"), comment, ddl, source },
+        ["tables", "schemas", "options"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.publication, { name }, props);
+    }
     case "domain": {
       const q = qualified(ctx, node.name);
       const checks = node.checks.map((c) => stripUnset({ name: c.name, expr: req(text(ctx, c.expr, "checks")), notValid: c.notValid }) as CheckDef);
@@ -1961,6 +2411,92 @@ export function eventTrigger(strings: TemplateStringsArray, ...values: unknown[]
   return build("eventTrigger", strings, values) as PostgresEventTrigger;
 }
 
+/**
+ * `` operator`CREATE OPERATOR app.=== (FUNCTION = ${fn}, LEFTARG = int, RIGHTARG = int)` ``:
+ * one operator, identified by its name and operand types, as a function is by
+ * its name and parameter types.
+ */
+export function operator(strings: TemplateStringsArray, ...values: unknown[]): PostgresOperator {
+  return build("operator", strings, values) as PostgresOperator;
+}
+
+/**
+ * `` operatorClass`CREATE OPERATOR CLASS app.ops DEFAULT FOR TYPE int USING btree AS OPERATOR 1 <, FUNCTION 1 ${cmp}(int, int)` ``:
+ * one operator class, identified by its name and index method. Creating one takes a superuser.
+ */
+export function operatorClass(strings: TemplateStringsArray, ...values: unknown[]): PostgresOperatorClass {
+  return build("operatorClass", strings, values) as PostgresOperatorClass;
+}
+
+/**
+ * `` operatorFamily`CREATE OPERATOR FAMILY app.ops USING btree` ``: one operator
+ * family, identified by its name and index method. Its members come with the
+ * operator classes that name it. Creating one takes a superuser.
+ */
+export function operatorFamily(strings: TemplateStringsArray, ...values: unknown[]): PostgresOperatorFamily {
+  return build("operatorFamily", strings, values) as PostgresOperatorFamily;
+}
+
+/**
+ * `` foreignTable`CREATE FOREIGN TABLE app.remote_orders (id int, total numeric) SERVER ${remote} OPTIONS (table_name 'orders')` ``:
+ * one foreign table. It has its own tag, not `table`, because it is another
+ * kind of relation: another CREATE and ALTER, no key, index, partitioning or
+ * storage clauses, and a server it cannot move off.
+ */
+export function foreignTable(strings: TemplateStringsArray, ...values: unknown[]): PostgresForeignTable {
+  return build("foreignTable", strings, values) as PostgresForeignTable;
+}
+
+/**
+ * `` textSearchDictionary`CREATE TEXT SEARCH DICTIONARY app.english_stop (TEMPLATE = snowball, Language = english, StopWords = english)` ``:
+ * one text search dictionary: a template and its options.
+ */
+export function textSearchDictionary(strings: TemplateStringsArray, ...values: unknown[]): PostgresTextSearchDictionary {
+  return build("textSearchDictionary", strings, values) as PostgresTextSearchDictionary;
+}
+
+/**
+ * `` textSearchConfiguration`CREATE TEXT SEARCH CONFIGURATION app.english2 (PARSER = default); ALTER TEXT SEARCH CONFIGURATION app.english2 ADD MAPPING FOR asciiword WITH ${dict}` ``:
+ * one text search configuration: a parser, and the dictionaries each token
+ * type it finds is looked up in.
+ */
+export function textSearchConfiguration(strings: TemplateStringsArray, ...values: unknown[]): PostgresTextSearchConfiguration {
+  return build("textSearchConfiguration", strings, values) as PostgresTextSearchConfiguration;
+}
+
+/**
+ * `` statistics`CREATE STATISTICS name (ndistinct, dependencies) ON a, b FROM ${table}` ``:
+ * extended statistics on columns or expressions of one table.
+ */
+export function statistics(strings: TemplateStringsArray, ...values: unknown[]): PostgresStatistics {
+  return build("statistics", strings, values) as PostgresStatistics;
+}
+
+/**
+ * `` foreignDataWrapper`CREATE FOREIGN DATA WRAPPER name HANDLER ${fn} OPTIONS (...)` ``:
+ * one foreign data wrapper, the database's (no schema). Creating one takes a superuser.
+ */
+export function foreignDataWrapper(strings: TemplateStringsArray, ...values: unknown[]): PostgresForeignDataWrapper {
+  return build("foreignDataWrapper", strings, values) as PostgresForeignDataWrapper;
+}
+
+/**
+ * `` foreignServer`CREATE SERVER name FOREIGN DATA WRAPPER ${fdw} OPTIONS (host 'db.internal')` ``:
+ * one foreign server, the database's. Its user mappings carry credentials and are
+ * not declared; an option that holds a secret is the environment's to supply.
+ */
+export function foreignServer(strings: TemplateStringsArray, ...values: unknown[]): PostgresForeignServer {
+  return build("foreignServer", strings, values) as PostgresForeignServer;
+}
+
+/**
+ * `` publication`CREATE PUBLICATION name FOR TABLE ${t} WITH (publish = 'insert')` ``:
+ * one logical-replication publication, the database's.
+ */
+export function publication(strings: TemplateStringsArray, ...values: unknown[]): PostgresPublication {
+  return build("publication", strings, values) as PostgresPublication;
+}
+
 /** `` trigger`CREATE [OR REPLACE] [CONSTRAINT] TRIGGER name ... ON ${table} ... EXECUTE FUNCTION ${fn}()` ``: one trigger on its table. */
 export function trigger(strings: TemplateStringsArray, ...values: unknown[]): PostgresTrigger {
   return build("trigger", strings, values) as PostgresTrigger;