@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/op/watch-pipeline.test.ts

@@ -13,7 +13,7 @@
  */
 
 import { join } from "node:path";
-import { describe, expect, test } from "vitest";
+import { beforeAll, describe, expect, test } from "vitest";
 import { generateOpsPipeline } from "@intentius/chant/op";
 import { parseYAML } from "@intentius/chant/yaml";
 import type { ScheduledOpSpec } from "@intentius/chant/lexicon";
@@ -58,6 +58,13 @@ async function render(forge: "github" | "gitlab" | "forgejo", spec: ScheduledOpS
 const runLine = (steps: Array<Record<string, unknown>>) => steps.find((s) => s.run === "chant run schema-watch");
 
 describe("generateOpsPipeline renders the sql drift watch (#3642)", () => {
+  // The first render loads the github, gitlab and forgejo plugins and discovers the example's Ops. On a loaded CI shard
+  // that cold load took 5.7s and put the first test over the 5s unit-test budget (chant #2817). A file's beforeAll is
+  // not counted against the budget, so the load is paid here and each test below times only its own render.
+  beforeAll(async () => {
+    await generateOpsPipeline([reader(actionsSecret)], "github", { beforeScript: INSTALL.actions }, EXAMPLE);
+  }, 60_000);
+
   test("GitHub: the Op's own cron, a read-only token and the reader's credentials", async () => {
     const { file, doc } = await render("github", reader(actionsSecret));
     expect(file.name).toBe("schema-watch.yml");

package/src/plugin.ts

@@ -18,7 +18,7 @@ import { completions } from "./lsp/completions";
 import { hover } from "./lsp/hover";
 import { sqlMcpResources, sqlMcpTools } from "./mcp";
 import { sqlConfigSchema } from "./config";
-import { SqlFileParser, dialectOption } from "./import-parser";
+import { SqlFileParser, dialectOption, sourceOption } from "./import-parser";
 import { sqlTemplateGenerator } from "./import-generator";
 import { sqlCommands } from "./clickhouse/plan/commands";
 import { sqlDeepNormalizationHooks } from "./clickhouse/plan/deep";
@@ -29,6 +29,7 @@ import { CLICKHOUSE_EMULATOR } from "./op/activities/clickhouse-emulator";
 import { POSTGRES_EMULATOR } from "./op/activities/postgres-emulator";
 import { sqlSkills } from "./skill-defs";
 import { detectTemplate } from "./detect";
+import { looksLikePostgres } from "./migrate/from-postgres/detect";
 import { sqlWorkspaceOutputs } from "./workspace-outputs";
 import { CDC_TEMPLATE, DEFAULT_TEMPLATE, EVENTS_TEMPLATE, POSTGRES_EVENTS_TEMPLATE, POSTGRES_TEMPLATE, POSTGRES_TENANT_TEMPLATE } from "./init-templates";
 import { compositeCatalog } from "./composites/catalog";
@@ -113,6 +114,16 @@ export const sqlPlugin: LexiconPlugin = {
       { name: "aggregate", isTag: true, description: "A Postgres CREATE AGGREGATE, parsed into an aggregate entity identified by its argument types" },
       { name: "trigger", isTag: true, description: "A Postgres CREATE TRIGGER, parsed into a trigger entity on its table" },
       { name: "eventTrigger", isTag: true, description: "A Postgres CREATE EVENT TRIGGER, parsed into the database's event trigger entity" },
+      { name: "operator", isTag: true, description: "A Postgres CREATE OPERATOR, parsed into an operator entity identified by its name and operand types" },
+      { name: "operatorClass", isTag: true, description: "A Postgres CREATE OPERATOR CLASS, parsed into an operator class entity identified by its name and index method" },
+      { name: "operatorFamily", isTag: true, description: "A Postgres CREATE OPERATOR FAMILY, parsed into an operator family entity identified by its name and index method" },
+      { name: "foreignTable", isTag: true, description: "A Postgres CREATE FOREIGN TABLE, parsed into a foreign table entity with its columns, server and options" },
+      { name: "textSearchConfiguration", isTag: true, description: "A Postgres CREATE TEXT SEARCH CONFIGURATION with its ADD MAPPING statements, parsed into a configuration entity" },
+      { name: "textSearchDictionary", isTag: true, description: "A Postgres CREATE TEXT SEARCH DICTIONARY, parsed into a dictionary entity with its template and options" },
+      { name: "statistics", isTag: true, description: "A Postgres CREATE STATISTICS, parsed into an extended statistics entity on its table" },
+      { name: "foreignDataWrapper", isTag: true, description: "A Postgres CREATE FOREIGN DATA WRAPPER, parsed into the database's wrapper entity" },
+      { name: "foreignServer", isTag: true, description: "A Postgres CREATE SERVER, parsed into the database's foreign server entity (user mappings are not declared)" },
+      { name: "publication", isTag: true, description: "A Postgres CREATE PUBLICATION, parsed into the database's publication entity" },
       { name: "collation", isTag: true, description: "A Postgres CREATE COLLATION, parsed into a collation entity" },
       { name: "cast", isTag: true, description: "A Postgres CREATE CAST, parsed into a cast entity named by its two types" },
       { name: "policy", isTag: true, description: "A Postgres CREATE POLICY, parsed into a row-level security policy on its table, or a ClickHouse CREATE ROW POLICY" },
@@ -166,7 +177,31 @@ export const sqlPlugin: LexiconPlugin = {
 
   /** `chant import schema.sql`: a file of Postgres or ClickHouse DDL (`./import-parser.ts`). */
   templateParser(options) {
-    return new SqlFileParser(dialectOption(options), { skipUndeclarable: options?.skipUndeclarable === true });
+    const from = sourceOption(options);
+    return new SqlFileParser(dialectOption(options), { skipUndeclarable: options?.skipUndeclarable === true, ...(from ? { from } : {}) });
+  },
+
+  /** `chant import --validate` (#4398): create the imported DDL on the pinned ClickHouse emulator. */
+  async validateImport(ir) {
+    const { validateOnEmulator } = await import("./sqlserver/validate");
+    return validateOnEmulator(ir);
+  },
+
+  /**
+   * `chant migrate --from sql/postgres --to sql/clickhouse` (#4399): the
+   * Postgres tables a CDC pipeline mirrors, as ClickHouse tables or
+   * `CdcMirror` calls (`./migrate/from-postgres/index.ts`).
+   */
+  migrationSource(from, to) {
+    if (from !== "sql/postgres" || (to !== undefined && to !== "sql/clickhouse")) return undefined;
+    return {
+      detect: looksLikePostgres,
+      directory: true,
+      async transform(content, opts) {
+        const { transform } = await import("./migrate/from-postgres/index");
+        return transform(content, opts);
+      },
+    };
   },
 
   parserOptions() {
@@ -176,6 +211,11 @@ export const sqlPlugin: LexiconPlugin = {
         type: "string" as const,
         description: "the DDL's dialect, clickhouse or postgres; read off its statements when omitted",
       },
+      {
+        name: "from",
+        type: "string" as const,
+        description: "read the file as a SQL Server schema (sqlserver) and translate it to ClickHouse; each judgment call is a needs-review diagnostic for --report and --strict",
+      },
       {
         name: "skipUndeclarable",
         type: "boolean" as const,
@@ -260,6 +300,15 @@ export const sqlPlugin: LexiconPlugin = {
     return { ...classifyDisruption(options), ...classifyPgDisruption(options) };
   },
 
+  /**
+   * The migration files a pull request adds (#4407): each up statement given
+   * the class the schema-diff classifier gives the same change. Offline.
+   */
+  async classifyMigrations(options) {
+    const { classifyMigrationFiles } = await import("./migration-classify");
+    return classifyMigrationFiles(options);
+  },
+
   /** `chant sql diff` and `chant sql plan`: schema changes, classified. */
   commands() {
     return sqlCommands;

package/src/postgres/access/acl.ts

@@ -188,7 +188,7 @@ export function declaredAccess(objects: ReadonlyArray<{ key: string; canonical:
   for (const { canonical: o } of objects) {
     const name = `${o.schema ? `${quoteIdent(o.schema)}.` : ""}${quoteIdent(o.name)}`;
     if (o.kind === "schema") declaredTargets.push({ kind: "schema", name: quoteIdent(o.name) });
-    else if (o.kind === "table" || o.kind === "view" || o.kind === "materializedView") {
+    else if (o.kind === "table" || o.kind === "foreignTable" || o.kind === "view" || o.kind === "materializedView") {
       relationKind.set(name, "table");
       declaredTargets.push({ kind: "table", name });
     } else if (o.kind === "sequence") {

package/src/postgres/access/import.ts

@@ -21,7 +21,7 @@ function targetsOf(objects: readonly LivePgObject[]): AclTarget[] {
   for (const o of objects) {
     const name = `${o.schema ? `${quoteIdent(o.schema)}.` : ""}${quoteIdent(o.name)}`;
     if (o.type === POSTGRES_ENTITY_TYPES.schema) out.push({ kind: "schema", name: quoteIdent(o.name) });
-    else if (o.type === POSTGRES_ENTITY_TYPES.table || o.type === POSTGRES_ENTITY_TYPES.view || o.type === POSTGRES_ENTITY_TYPES.materializedView) out.push({ kind: "table", name });
+    else if (o.type === POSTGRES_ENTITY_TYPES.table || o.type === POSTGRES_ENTITY_TYPES.foreignTable || o.type === POSTGRES_ENTITY_TYPES.view || o.type === POSTGRES_ENTITY_TYPES.materializedView) out.push({ kind: "table", name });
     else if (o.type === POSTGRES_ENTITY_TYPES.sequence) out.push({ kind: "sequence", name });
     else if (o.type === POSTGRES_ENTITY_TYPES.function || o.type === POSTGRES_ENTITY_TYPES.procedure) {
       out.push({ kind: o.type === POSTGRES_ENTITY_TYPES.function ? "function" : "procedure", name: `${name}${o.signature ?? ""}` });

package/src/postgres/apply/apply.ts

@@ -553,6 +553,9 @@ async function applyAccess(
   }
 }
 
+/** The kinds that belong to the database, not a schema. */
+const UNPLACED_KINDS: ReadonlySet<CanonicalKind> = new Set(["eventTrigger", "foreignDataWrapper", "foreignServer", "publication"]);
+
 /** The address a live object is keyed by in the diff. */
 function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?: string; name: string; signature?: string } {
   const kind = (
@@ -571,6 +574,16 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
       "Postgres::Collation": "collation",
       "Postgres::Cast": "cast",
       "Postgres::EventTrigger": "eventTrigger",
+      "Postgres::Operator": "operator",
+      "Postgres::OperatorClass": "operatorClass",
+      "Postgres::OperatorFamily": "operatorFamily",
+      "Postgres::ForeignTable": "foreignTable",
+      "Postgres::TextSearchConfiguration": "textSearchConfiguration",
+      "Postgres::TextSearchDictionary": "textSearchDictionary",
+      "Postgres::Statistics": "statistics",
+      "Postgres::ForeignDataWrapper": "foreignDataWrapper",
+      "Postgres::ForeignServer": "foreignServer",
+      "Postgres::Publication": "publication",
       "Postgres::Extension": "extension",
       "Postgres::Function": "function",
       "Postgres::Procedure": "procedure",
@@ -583,7 +596,7 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
   )[o.type];
   return {
     kind,
-    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" && kind !== "cast" && kind !== "eventTrigger" ? { schema: o.schema } : {}),
+    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" && kind !== "cast" && !UNPLACED_KINDS.has(kind) ? { schema: o.schema } : {}),
     name: o.name,
     ...(o.signature !== undefined ? { signature: o.signature } : {}),
   };

package/src/postgres/apply/statements.ts

@@ -34,7 +34,7 @@ import { ACCESS_KINDS, canonicalOptions, sameConstraint, type CanonicalConstrain
 import type { PgDiffObject, PgSchemaObject } from "../plan/schema";
 import { migrationTarget } from "../migrate/handoff";
 import { pgName } from "../migrate/names";
-import type { CheckDef, ColumnDef, DomainProps, ExclusionDef, ForeignKeyDef, IndexProps, KeyDef, PolicyProps, SequenceProps, TableProps } from "../entities";
+import type { CheckDef, ColumnDef, DomainProps, ForeignTableProps, TextSearchConfigurationProps, ExclusionDef, ForeignKeyDef, IndexProps, KeyDef, PolicyProps, SequenceProps, TableProps } from "../entities";
 
 const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
 
@@ -108,10 +108,12 @@ export const pgQualified = (schema: string | undefined, name: string): string =>
 export const objectIdent = (o: { kind: CanonicalKind; schema?: string; name: string; signature?: string }): string =>
   o.kind === "cast"
     ? o.name
-    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger"
+    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger" || o.kind === "foreignDataWrapper" || o.kind === "foreignServer" || o.kind === "publication"
     ? quoteIdent(o.name)
     : o.kind === "trigger" || o.kind === "policy"
       ? `${quoteIdent(o.name)}${o.signature ?? ""}`
+      : o.kind === "operator"
+        ? `${o.schema ? `${quoteIdent(o.schema)}.` : ""}${o.name}${o.signature ?? ""}`
       : `${pgQualified(o.schema, o.name)}${o.signature ?? ""}`;
 
 /** The words a statement names the object's kind with. */
@@ -133,6 +135,16 @@ export const KIND_WORDS: Readonly<Record<CanonicalKind, string>> = {
   collation: "COLLATION",
   cast: "CAST",
   eventTrigger: "EVENT TRIGGER",
+  operator: "OPERATOR",
+  operatorClass: "OPERATOR CLASS",
+  operatorFamily: "OPERATOR FAMILY",
+  foreignTable: "FOREIGN TABLE",
+  textSearchConfiguration: "TEXT SEARCH CONFIGURATION",
+  textSearchDictionary: "TEXT SEARCH DICTIONARY",
+  statistics: "STATISTICS",
+  foreignDataWrapper: "FOREIGN DATA WRAPPER",
+  foreignServer: "SERVER",
+  publication: "PUBLICATION",
   trigger: "TRIGGER",
   policy: "POLICY",
   role: "ROLE",
@@ -315,7 +327,7 @@ function identitySetClauses(options: string | undefined): string[] {
   return out;
 }
 
-const COLUMN_FIELD = /^columns\.(.+?)(?:\.(type|default|notNull|generated|identity|collate|storage|comment))?$/;
+const COLUMN_FIELD = /^columns\.(.+?)(?:\.(type|default|notNull|generated|identity|collate|storage|options|comment))?$/;
 
 // ── Constraints ────────────────────────────────────────────────────────
 
@@ -569,6 +581,181 @@ export function setNotNullSteps(table: string, column: string, live?: Pick<PgDif
   return steps;
 }
 
+/** An `OPTIONS (...)` clause that takes the options `have` to `want`: ADD, SET and DROP per option; empty when they agree. */
+function optionsClause(want: unknown, have: unknown): string {
+  const w = (want ?? {}) as Record<string, string>;
+  const h = (have ?? {}) as Record<string, string>;
+  const parts = [
+    ...Object.keys(w).filter((k) => !(k in h)).map((k) => `ADD ${quoteIdent(k)} ${pgString(w[k]!)}`),
+    ...Object.keys(w).filter((k) => k in h && h[k] !== w[k]).map((k) => `SET ${quoteIdent(k)} ${pgString(w[k]!)}`),
+    ...Object.keys(h).filter((k) => !(k in w)).map((k) => `DROP ${quoteIdent(k)}`),
+  ];
+  return parts.length > 0 ? `OPTIONS (${parts.join(", ")})` : "";
+}
+
+/** A publication's table as `ADD TABLE` writes it: its name, column list and row filter. */
+const publicationTable = (t: { table: string; columns?: string[]; where?: string }): string =>
+  `${t.table}${t.columns && t.columns.length > 0 ? ` (${t.columns.map(quoteIdent).join(", ")})` : ""}${t.where ? ` WHERE (${t.where})` : ""}`;
+
+/**
+ * The ALTER statements that take a foreign data wrapper, a foreign server or
+ * a publication to the declaration, in place (SQLPG303): one ALTER for a
+ * wrapper or server; for a publication one SET (...) for its options, and a
+ * DROP and ADD per table or schema that changed.
+ */
+function alteredSteps(d: PgDiffObject, live: PgDiffObject, target: string): PgStep[] {
+  const out: string[] = [];
+  const f = d.fields;
+  const l = live.fields;
+  if (d.kind === "foreignDataWrapper") {
+    const clauses = [
+      !same(f.handler, l.handler) ? (f.handler ? `HANDLER ${String(f.handler)}` : "NO HANDLER") : "",
+      !same(f.validator, l.validator) ? (f.validator ? `VALIDATOR ${String(f.validator)}` : "NO VALIDATOR") : "",
+      optionsClause(f.options, l.options),
+    ].filter(Boolean);
+    if (clauses.length > 0) out.push(`ALTER FOREIGN DATA WRAPPER ${target} ${clauses.join(" ")}`);
+  } else if (d.kind === "foreignServer") {
+    const clauses = [!same(f.version, l.version) ? `VERSION ${f.version === undefined ? "NULL" : pgString(String(f.version))}` : "", optionsClause(f.options, l.options)].filter(Boolean);
+    if (clauses.length > 0) out.push(`ALTER SERVER ${target} ${clauses.join(" ")}`);
+  } else if (d.kind === "publication") {
+    const sets: string[] = [];
+    if (!same(f.publish, l.publish)) sets.push(`publish = ${pgString(((f.publish as string[] | undefined) ?? ["insert", "update", "delete", "truncate"]).join(", "))}`);
+    if (!same(f.viaRoot, l.viaRoot)) sets.push(`publish_via_partition_root = ${f.viaRoot === true}`);
+    if (!same(f.generatedColumns, l.generatedColumns)) sets.push(`publish_generated_columns = ${String(f.generatedColumns ?? "none")}`);
+    if (sets.length > 0) out.push(`ALTER PUBLICATION ${target} SET (${sets.join(", ")})`);
+    type Member = { table: string; columns?: string[]; where?: string };
+    const want = (f.tables as Member[] | undefined) ?? [];
+    const have = (l.tables as Member[] | undefined) ?? [];
+    const kept = (m: Member) => want.some((w) => w.table === m.table && same(w, m));
+    for (const m of have) if (!kept(m)) out.push(`ALTER PUBLICATION ${target} DROP TABLE ${m.table}`);
+    for (const m of want) if (!have.some((h) => h.table === m.table && same(h, m))) out.push(`ALTER PUBLICATION ${target} ADD TABLE ${publicationTable(m)}`);
+    const wantSchemas = (f.schemas as string[] | undefined) ?? [];
+    const haveSchemas = (l.schemas as string[] | undefined) ?? [];
+    for (const s of haveSchemas) if (!wantSchemas.includes(s)) out.push(`ALTER PUBLICATION ${target} DROP TABLES IN SCHEMA ${s}`);
+    for (const s of wantSchemas) if (!haveSchemas.includes(s)) out.push(`ALTER PUBLICATION ${target} ADD TABLES IN SCHEMA ${s}`);
+  }
+  return out.map((sql) => step(sql, "metadata", "SQLPG303"));
+}
+
+
+// ── Operators, text search and foreign tables (#4406) ──────────────────
+
+/**
+ * The clauses of `ALTER OPERATOR ... SET (...)` for the attributes the diff
+ * found changeable in place (SQLPG304): RESTRICT and JOIN to the declared
+ * estimator or NONE, COMMUTATOR and NEGATOR to the declared operator, and
+ * HASHES and MERGES as bare words, since they can only be turned on.
+ */
+function operatorSetClauses(d: PgDiffObject, changes: readonly PgChange[]): string[] {
+  const definition = (d.fields.definition ?? {}) as Record<string, string>;
+  return changes.map((c) => {
+    const key = c.field.replace(/^definition\./, "");
+    const value = definition[key];
+    if (key === "hashes" || key === "merges") return key.toUpperCase();
+    if (key === "commutator" || key === "negator") return `${key.toUpperCase()} = OPERATOR(${value})`;
+    return `${key.toUpperCase()} = ${value ?? "NONE"}`;
+  });
+}
+
+/**
+ * A text search configuration's mappings, or a dictionary's options, taken to
+ * the declaration in place (SQLPG305). For a configuration: DROP MAPPING for
+ * the token types no longer mapped, ALTER MAPPING for those whose dictionaries
+ * changed, ADD MAPPING for the new ones, one statement for the token types
+ * that share their dictionaries; the dictionaries are named as the
+ * declaration wrote them. For a dictionary: one ALTER with each option that
+ * differs set, and each option the declaration dropped named with no value,
+ * which removes it.
+ */
+function textSearchSteps(obj: DeclaredPgObject, live: PgDiffObject, target: string): PgStep[] {
+  const d = obj.canonical;
+  if (d.kind === "textSearchDictionary") {
+    const want = (d.fields.options ?? {}) as Record<string, string>;
+    const have = (live.fields.options ?? {}) as Record<string, string>;
+    const parts = [
+      ...Object.keys(want).filter((k) => have[k] !== want[k]).map((k) => `${quoteIdent(k)} = ${pgString(want[k]!)}`),
+      ...Object.keys(have).filter((k) => !(k in want)).map((k) => quoteIdent(k)),
+    ];
+    return parts.length > 0 ? [step(`ALTER TEXT SEARCH DICTIONARY ${target} (${parts.join(", ")})`, "metadata", "SQLPG305")] : [];
+  }
+  const want = (d.fields.mappings ?? {}) as Record<string, string[]>;
+  const have = (live.fields.mappings ?? {}) as Record<string, string[]>;
+  const written = new Map<string, string[]>();
+  for (const m of (obj.props as unknown as TextSearchConfigurationProps).mappings) for (const t of m.tokens) written.set(t.toLowerCase(), m.dictionaries);
+  const group = (tokens: string[]): Map<string, string[]> => {
+    const out = new Map<string, string[]>();
+    for (const t of tokens) {
+      const key = JSON.stringify(want[t]);
+      out.set(key, [...(out.get(key) ?? []), t]);
+    }
+    return out;
+  };
+  const dropped = Object.keys(have).filter((t) => !(t in want));
+  const added = Object.keys(want).filter((t) => !(t in have));
+  const changed = Object.keys(want).filter((t) => t in have && JSON.stringify(have[t]) !== JSON.stringify(want[t]));
+  const names = (tokens: string[]) => tokens.map(quoteIdent).join(", ");
+  const out: PgStep[] = [];
+  if (dropped.length > 0) out.push(step(`ALTER TEXT SEARCH CONFIGURATION ${target} DROP MAPPING FOR ${names(dropped)}`, "metadata", "SQLPG305"));
+  for (const [verb, tokens] of [["ALTER", changed], ["ADD", added]] as const) {
+    for (const members of group(tokens).values()) out.push(step(`ALTER TEXT SEARCH CONFIGURATION ${target} ${verb} MAPPING FOR ${names(members)} WITH ${written.get(members[0]!)!.join(", ")}`, "metadata", "SQLPG305"));
+  }
+  return out;
+}
+
+/**
+ * A foreign table's changes in place (SQLPG306), as ALTER FOREIGN TABLE
+ * makes them: ADD and DROP COLUMN, a column's type, default, NOT NULL and
+ * OPTIONS, CHECK constraints added and dropped, and the table's OPTIONS.
+ * A column added with options gets them in an ALTER of its own, since ADD
+ * COLUMN has no OPTIONS clause.
+ */
+function foreignTableSteps(c: PgChange, obj: DeclaredPgObject, live: PgDiffObject, alterKind: string): PgStep[] {
+  const d = obj.canonical;
+  const props = obj.props as unknown as ForeignTableProps;
+  const make = (sql: string) => step(sql, "metadata", "SQLPG306");
+  if (c.field === "options") {
+    const clause = optionsClause(d.fields.options, live.fields.options);
+    return clause ? [make(`${alterKind} ${clause}`)] : [];
+  }
+  if (c.field.startsWith("constraints.")) {
+    const key = c.field.slice("constraints.".length);
+    // A declared CHECK the server lacks is added; one it has and the declaration dropped is dropped by the server's name.
+    if (c.before === undefined) {
+      const i = d.constraints.findIndex((a) => (a.name ?? a.kind.toLowerCase()) === key && !live.constraints.some((b) => sameConstraint(a, b)));
+      return i >= 0 && props.checks[i] ? [make(`${alterKind} ADD ${constraintSql("CHECK", props.checks[i]!)}`)] : [];
+    }
+    return [make(`${alterKind} DROP CONSTRAINT ${quoteIdent(key)}`)];
+  }
+  const m = COLUMN_FIELD.exec(c.field);
+  if (!m) return [];
+  const name = m[1]!;
+  const prop = m[2];
+  const def = props.columns.find((x) => x.name === name);
+  const column = `${alterKind} ALTER COLUMN ${quoteIdent(name)}`;
+  const liveColumn = live.columns.find((x) => x.name === name);
+  if (prop === undefined) {
+    if (!def) return [make(`${alterKind} DROP COLUMN ${quoteIdent(name)}`)];
+    const options = optionsClause(def.options, undefined);
+    return [make(`${alterKind} ADD COLUMN ${columnDefinition(def)}`), ...(options ? [make(`${column} ${options}`)] : [])];
+  }
+  if (!def) return [];
+  switch (prop) {
+    case "type":
+    case "collate":
+      return def.type ? [make(`${column} TYPE ${def.type}${def.collate ? ` COLLATE ${def.collate}` : prop === "collate" ? ' COLLATE "default"' : ""}`)] : [];
+    case "default":
+      return [make(def.default !== undefined ? `${column} SET DEFAULT ${def.default}` : `${column} DROP DEFAULT`)];
+    case "notNull":
+      return [make(`${column} ${def.notNull ? "SET" : "DROP"} NOT NULL`)];
+    case "options": {
+      const clause = optionsClause(def.options, liveColumn?.options);
+      return clause ? [make(`${column} ${clause}`)] : [];
+    }
+    default:
+      return [];
+  }
+}
+
 /**
  * The statements for an object that exists on the server, change by change.
  * `live` is the server's definition, matched to the declaration (a renamed
@@ -604,13 +791,23 @@ export function alterSteps(
       steps.push(...createSteps(obj, opts.marker, { cls: c.class, rule: c.rule }));
       continue;
     }
+    if (c.rule === "SQLPG306") {
+      steps.push(...foreignTableSteps(c, obj, live, alterKind));
+      continue;
+    }
+    if (d.kind === "foreignTable" && c.rule === "SQLPG216" && /^constraints\.[^.]+\.comment$/.test(c.field)) {
+      const name = c.field.split(".")[1]!;
+      const declared = d.constraints.find((a) => (a.name ?? a.kind.toLowerCase()) === name);
+      steps.push(step(`COMMENT ON CONSTRAINT ${quoteIdent(name)} ON ${target} IS ${declared?.comment === undefined ? "NULL" : pgString(declared.comment)}`, c.class, c.rule));
+      continue;
+    }
     if (c.field.startsWith("constraints.")) {
       if (!constraintsDone) steps.push(...constraintSteps(obj, live, notNullChecks));
       constraintsDone = true;
       continue;
     }
     const col = COLUMN_FIELD.exec(c.field);
-    if (col && (d.kind === "table")) {
+    if (col && (d.kind === "table" || d.kind === "foreignTable")) {
       const name = col[1]!;
       const prop = col[2];
       const def = columns.get(name);
@@ -704,6 +901,15 @@ export function alterSteps(
       case "SQLPG229":
         steps.push(step(`ALTER INDEX ${objectIdent(live)} RENAME TO ${quoteIdent(d.name)}`, c.class, c.rule));
         break;
+      case "SQLPG303":
+        if (!steps.some((s) => s.rule === "SQLPG303")) steps.push(...alteredSteps(d, live, target));
+        break;
+      case "SQLPG304":
+        if (!steps.some((s) => s.rule === "SQLPG304")) steps.push(step(`ALTER OPERATOR ${target} SET (${operatorSetClauses(d, changes.filter((x) => x.rule === "SQLPG304")).join(", ")})`, c.class, c.rule));
+        break;
+      case "SQLPG305":
+        if (!steps.some((s) => s.rule === "SQLPG305")) steps.push(...textSearchSteps(obj, live, target));
+        break;
       case "SQLPG250":
       case "SQLPG280":
       case "SQLPG302":
@@ -882,15 +1088,30 @@ const DROP_ORDER: Record<CanonicalKind, number> = {
   defaultPrivileges: 0,
   policy: 0,
   trigger: 0,
+  // A publication reads tables, extended statistics are on one: both go before it.
+  publication: 0,
+  statistics: 0,
   materializedView: 1,
   view: 2,
   index: 3,
   table: 4,
+  // A foreign table reads a foreign server (below) and a type; a view on it goes before.
+  foreignTable: 4,
   sequence: 5,
   // An event trigger and a cast before the function they call; an aggregate before its functions.
   eventTrigger: 5.5,
   cast: 5.5,
   aggregate: 5.5,
+  operator: 5.5,
+  // A class names operators and functions; a family goes after its classes.
+  operatorClass: 5.2,
+  operatorFamily: 5.3,
+  // A configuration maps token types to dictionaries, so it goes first.
+  textSearchConfiguration: 5.7,
+  textSearchDictionary: 5.8,
+  // A server before its wrapper, a wrapper before the handler function it calls.
+  foreignServer: 5.5,
+  foreignDataWrapper: 5.6,
   // A routine after what calls it (a view, a trigger, a default), before the types its parameters use.
   function: 6,
   procedure: 6,

package/src/postgres/constraint-names.ts

@@ -0,0 +1,71 @@
+/**
+ * The names Postgres gives a constraint or an index that the DDL leaves
+ * unnamed, so a reader of the declarations can spell them without a server.
+ *
+ * `makeObjectName` and the `Choose*Name` functions are from the Postgres
+ * source (`src/backend/commands/indexcmds.c`, `src/backend/catalog/heap.c`,
+ * `src/backend/commands/tablecmds.c`): the table name, then the column
+ * names joined with `_`, then a label (`pkey`, `key`, `fkey`, `check`),
+ * cut to 63 bytes by shortening the longer of the first two parts one
+ * character at a time. A name already taken gets a number after the label
+ * (`orders_pkey1`).
+ *
+ * A name the author writes always wins; these are for the rest. Drizzle's
+ * own derived names (`orders_user_id_users_id_fk`) differ from them, which is
+ * why the Drizzle export names every constraint it writes.
+ */
+
+const NAMEDATALEN = 64;
+
+/** `makeObjectName(name1, name2, label)`: ASCII names only. */
+export function makeObjectName(name1: string, name2: string | undefined, label: string | undefined): string {
+  let overhead = 0;
+  let n2 = 0;
+  if (name2 !== undefined) {
+    n2 = name2.length;
+    overhead++;
+  }
+  if (label !== undefined) overhead += label.length + 1;
+  const avail = NAMEDATALEN - 1 - overhead;
+  let n1 = name1.length;
+  while (n1 + n2 > avail) {
+    if (n1 > n2) n1--;
+    else n2--;
+  }
+  let name = name1.slice(0, n1);
+  if (name2 !== undefined) name += `_${name2.slice(0, n2)}`;
+  if (label !== undefined) name += `_${label}`;
+  return name;
+}
+
+/** The first of `label`, `label1`, `label2`, ... that gives a name not in `taken`. */
+export function chooseName(name1: string, name2: string | undefined, label: string, taken: ReadonlySet<string>): string {
+  let pass = 0;
+  let candidate = makeObjectName(name1, name2, label);
+  while (taken.has(candidate)) candidate = makeObjectName(name1, name2, `${label}${++pass}`);
+  return candidate;
+}
+
+/** The column names of a key or foreign key, joined as Postgres joins them. */
+export const columnsAddition = (columns: readonly string[]): string => columns.join("_");
+
+/**
+ * The identifiers `expr` reads as column names: words outside quotes and
+ * string literals that are not followed by `(`, and are in `columns`.
+ */
+export function referencedColumns(expr: string, columns: readonly string[]): string[] {
+  const known = new Set(columns);
+  const found = new Set<string>();
+  const re = /'(?:[^']|'')*'|"((?:[^"]|"")+)"|([A-Za-z_][\w$]*)(?!\s*\()(?!\s*\.)/g;
+  for (let m = re.exec(expr); m; m = re.exec(expr)) {
+    const name = m[1] !== undefined ? m[1].replace(/""/g, '"') : m[2];
+    if (name !== undefined && known.has(m[1] !== undefined ? name : name.toLowerCase())) found.add(m[1] !== undefined ? name : name.toLowerCase());
+  }
+  return [...found];
+}
+
+/** A check constraint's default name: the column when the expression reads one, else just the table. */
+export function checkName(table: string, expr: string, columns: readonly string[], taken: ReadonlySet<string>): string {
+  const refs = referencedColumns(expr, columns);
+  return chooseName(table, refs.length === 1 ? refs[0] : undefined, "check", taken);
+}