@intentius/chant-lexicon-sql 0.117.0 → 0.118.0

package/src/clickhouse/apply/statements.ts

@@ -24,6 +24,7 @@ import { CLASSIFIER_RULES, type ChangeClass, type ClassifierRuleId } from "../pl
 import { stampedComment } from "../ownership";
 import { CLICKHOUSE_ENTITY_TYPES, type ClickHouseEntityType } from "../entities";
 import { renderFor, type Topology } from "../topology";
+import { accessClauseText, alterAccessField, grantStatement, revokeStatement, SECRETLESS, type GrantAtom } from "../access";
 
 /** A backquoted identifier. */
 export const ident = (name: string): string => `\`${name.replace(/`/g, "``")}\``;
@@ -124,6 +125,11 @@ export function createStatement(
   opts: { orReplace?: boolean; trailer?: Readonly<Record<string, string>> } = {},
 ): string {
   const { tokens, node } = parsed(obj);
+  // A function has no comment to carry the marker: it is sent as declared.
+  if (node.statement === "function") {
+    const body = statementBody(tokens);
+    return opts.orReplace && !node.orReplace ? body.replace(/^(\s*(?:--[^\n]*\n\s*)*)CREATE\s+/i, "$1CREATE OR REPLACE ") : body;
+  }
   const literal = sqlString(stampedComment(obj.canonical.comment, marker, opts.trailer));
   let sql: string;
   if (node.comment) {
@@ -137,7 +143,7 @@ export function createStatement(
   } else {
     sql = `${statementBody(tokens)} COMMENT ${literal}`;
   }
-  if (opts.orReplace && node.statement === "view" && !node.orReplace) {
+  if (opts.orReplace && (node.statement === "view" || node.statement === "dictionary") && !node.orReplace) {
     sql = sql.replace(/^(\s*(?:--[^\n]*\n\s*)*)CREATE\s+/i, "$1CREATE OR REPLACE ");
   }
   return sql;
@@ -154,7 +160,8 @@ export function commentStatement(obj: DeclaredObject, marker: OwnershipMarker |
 /** The `DROP` for an object a prune removes. `SYNC` so the name is free when it returns. */
 export function dropStatement(type: string, database: string | undefined, name: string): string {
   if (type === CLICKHOUSE_ENTITY_TYPES.database) return `DROP DATABASE ${ident(name)} SYNC`;
-  const what = type === CLICKHOUSE_ENTITY_TYPES.table ? "TABLE" : "VIEW";
+  if (type === CLICKHOUSE_ENTITY_TYPES.function) return `DROP FUNCTION ${ident(name)}`;
+  const what = type === CLICKHOUSE_ENTITY_TYPES.table ? "TABLE" : type === CLICKHOUSE_ENTITY_TYPES.dictionary ? "DICTIONARY" : "VIEW";
   return `DROP ${what} ${qualifiedIdent(database, name)} SYNC`;
 }
 
@@ -388,7 +395,15 @@ export function alterSteps(obj: DeclaredObject, changes: readonly Change[], opts
   for (const c of changes.filter((x) => x.rule === "SQLCH230")) {
     const from = splitQualified(c.before!);
     const to = splitQualified(c.after!);
-    steps.push(stepFor(`RENAME TABLE ${qualifiedIdent(from.database, from.name)} TO ${qualifiedIdent(to.database, to.name)}`, "SQLCH230"));
+    const what = obj.type === CLICKHOUSE_ENTITY_TYPES.dictionary ? "DICTIONARY" : "TABLE";
+    steps.push(stepFor(`RENAME ${what} ${qualifiedIdent(from.database, from.name)} TO ${qualifiedIdent(to.database, to.name)}`, "SQLCH230"));
+  }
+  if (obj.type === CLICKHOUSE_ENTITY_TYPES.function && changes.some((c) => c.rule === "SQLCH260")) {
+    steps.push(stepFor(createStatement(obj, opts.marker, { orReplace: true }), "SQLCH260"));
+  }
+  // A dictionary is replaced whole, its comment and marker with it.
+  if (obj.type === CLICKHOUSE_ENTITY_TYPES.dictionary && changes.some((c) => c.rule === "SQLCH245")) {
+    steps.push(stepFor(createStatement(obj, opts.marker, { orReplace: true }), "SQLCH245"));
   }
   if (obj.type === CLICKHOUSE_ENTITY_TYPES.table) steps.push(...tableSteps(obj, changes, opts.live));
   else if (obj.type === CLICKHOUSE_ENTITY_TYPES.view || obj.type === CLICKHOUSE_ENTITY_TYPES.materializedView) steps.push(...viewSteps(obj, changes, opts.marker));
@@ -397,7 +412,10 @@ export function alterSteps(obj: DeclaredObject, changes: readonly Change[], opts
 
 /** Whether the steps for these changes already set the object's comment (a plain view replaced whole). */
 export function stepsSetComment(obj: DeclaredObject, changes: readonly Change[]): boolean {
-  return obj.type === CLICKHOUSE_ENTITY_TYPES.view && changes.some((c) => c.rule === "SQLCH240");
+  return (
+    (obj.type === CLICKHOUSE_ENTITY_TYPES.view && changes.some((c) => c.rule === "SQLCH240")) ||
+    (obj.type === CLICKHOUSE_ENTITY_TYPES.dictionary && changes.some((c) => c.rule === "SQLCH245"))
+  );
 }
 
 // ── a schema's statements ─────────────────────────────────────────────
@@ -459,8 +477,8 @@ export interface StatementPlan {
   drops: DropStatement[];
 }
 
-/** Drop order: what reads from a table before the table, a database last. */
-const DROP_ORDER: Record<string, number> = { materializedView: 0, view: 1, table: 2, database: 3 };
+/** Drop order: what reads from a table before the table (a dictionary before its source), a database last. */
+const DROP_ORDER: Record<string, number> = { materializedView: 0, view: 1, dictionary: 2, table: 3, database: 4, function: 5 };
 
 /**
  * The statements that take the current schema to the declared one, from the
@@ -481,14 +499,89 @@ export function planStatements(input: StatementPlanInput): StatementPlan {
   };
 }
 
+const NEVER_DROPPED: ReadonlySet<string> = new Set(["function", "user", "role", "rowPolicy", "grants"]);
+
+/** The entity types of access control (`../access.ts`): no comment, no marker, never dropped. */
+export const ACCESS_TYPES: ReadonlySet<string> = new Set([
+  CLICKHOUSE_ENTITY_TYPES.user,
+  CLICKHOUSE_ENTITY_TYPES.role,
+  CLICKHOUSE_ENTITY_TYPES.rowPolicy,
+  CLICKHOUSE_ENTITY_TYPES.grant,
+]);
+
+/** What a user, role, row policy or grantee's grants take (`../access.ts`). */
+function accessStatements(obj: DeclaredObject, mine: Change[], live: CanonicalObject | undefined, deferred: DeferredDefaultRoles): ObjectStatements {
+  const kind = obj.canonical.kind;
+  const name = obj.canonical.name;
+  if (kind === "grants") {
+    const atom = (json: string | undefined) => JSON.parse(json ?? "{}") as GrantAtom;
+    const declared = obj.canonical.access ?? {};
+    const current = live?.access ?? {};
+    const created = mine.some((c) => c.rule === "SQLCH200");
+    const revokes = created ? [] : mine.filter((c) => c.rule === "SQLCH274").map((c) => stepFor(revokeStatement(atom(current[c.before as string]), name), "SQLCH274"));
+    const grants = (created ? Object.keys(declared) : mine.filter((c) => c.rule === "SQLCH273").map((c) => c.after as string)).map((key) =>
+      stepFor(grantStatement(atom(declared[key]), name), "SQLCH273"),
+    );
+    // A user's DEFAULT ROLE names roles it must already hold: set after its grants.
+    const defaultRole = deferred.get(name);
+    const after = defaultRole ? [defaultRole.step] : [];
+    if (defaultRole) mine = [...mine, defaultRole.change];
+    return { verdict: created ? "create" : "alter", obj, changes: mine, steps: [...revokes, ...grants, ...after] };
+  }
+  const body = statementBody(tokenizeText(obj.ddl, 0));
+  if (mine.some((c) => c.rule === "SQLCH200")) {
+    const method = obj.canonical.access?.identified?.split(" ")[0];
+    if (kind === "user" && (method === undefined || !SECRETLESS.has(method))) {
+      return {
+        verdict: "withheld",
+        obj,
+        changes: mine,
+        withheld: mine,
+        detail: `the user's password is the environment's, so chant does not create it: create ${name} with its password (CREATE USER ${ident(name)} IDENTIFIED BY ...), and the next apply makes the rest of it as declared`,
+      };
+    }
+    return { verdict: "create", obj, changes: mine, steps: [stepFor(body, "SQLCH200")] };
+  }
+  if (kind === "rowPolicy") {
+    // `CREATE ROW POLICY OR REPLACE`: ClickHouse takes OR REPLACE after the kind.
+    const replace = /^\s*(?:--[^\n]*\n\s*)*CREATE\s+(?:ROW\s+)?POLICY\s+OR\s+REPLACE\b/i.test(body)
+      ? body
+      : body.replace(/^(\s*(?:--[^\n]*\n\s*)*CREATE\s+(?:ROW\s+)?POLICY)\s+(?:IF\s+NOT\s+EXISTS\s+)?/i, "$1 OR REPLACE ");
+    return { verdict: "alter", obj, changes: mine, steps: mine.some((c) => c.rule === "SQLCH272") ? [stepFor(replace, "SQLCH272")] : [] };
+  }
+  const clauses = accessClauseText(obj.ddl);
+  const rule = kind === "user" ? "SQLCH271" : "SQLCH270";
+  const steps = mine
+    .filter((c) => c.rule === rule && !(kind === "user" && c.field === "defaultRole" && deferred.has(name)))
+    .map((c) => stepFor(alterAccessField(kind as "user" | "role", name, c.field, obj.canonical.access ?? {}, clauses), rule));
+  return { verdict: "alter", obj, changes: mine, steps };
+}
+
+/** The `ALTER USER ... DEFAULT ROLE` of each user whose grants the build also declares, by user: it runs after them. */
+type DeferredDefaultRoles = Map<string, { step: Step; change: Change }>;
+
+function deferredDefaultRoles(declared: readonly DeclaredObject[], byObject: ReadonlyMap<string, Change[]>, keyOf: (o: DeclaredObject) => string): DeferredDefaultRoles {
+  const out: DeferredDefaultRoles = new Map();
+  const grantees = new Set(declared.filter((o) => o.canonical.kind === "grants").map((o) => o.canonical.name));
+  for (const o of declared) {
+    if (o.canonical.kind !== "user" || !grantees.has(o.canonical.name)) continue;
+    const change = (byObject.get(keyOf(o)) ?? []).find((c) => c.rule === "SQLCH271" && c.field === "defaultRole");
+    if (!change) continue;
+    out.set(o.canonical.name, { step: stepFor(alterAccessField("user", o.canonical.name, "defaultRole", o.canonical.access ?? {}, accessClauseText(o.ddl)), "SQLCH271"), change });
+  }
+  return out;
+}
+
 function planDeclared(input: StatementPlanInput): StatementPlan {
   const keyOf = input.keyOf ?? ((o: DeclaredObject) => o.key);
   const byObject = new Map<string, Change[]>();
   for (const c of input.changes) byObject.set(c.object, [...(byObject.get(c.object) ?? []), c]);
+  const deferred = deferredDefaultRoles(input.declared, byObject, keyOf);
 
   const objects: ObjectStatements[] = input.declared.map((obj): ObjectStatements => {
     const key = keyOf(obj);
     const mine = byObject.get(key) ?? [];
+    if (ACCESS_TYPES.has(obj.type)) return accessStatements(obj, mine, input.current.get(key), deferred);
     const refused = mine.filter(isRebuild);
     if (refused.length > 0) return { verdict: "rebuild", obj, changes: mine, refused, detail: refusalDetail(refused, obj.key, obj.type) };
     const destructive = mine.filter(isDestructiveAlter);
@@ -506,7 +599,9 @@ function planDeclared(input: StatementPlanInput): StatementPlan {
     const renamedFrom = mine.find((c) => c.rule === "SQLCH230" || c.rule === "SQLCH231")?.before;
     const currentKey = renamedFrom !== undefined && input.current.has(renamedFrom) ? renamedFrom : key;
     const live = input.current.get(currentKey);
-    const restamp = !stepsSetComment(obj, mine) && (mine.some((c) => c.field === "comment") || !(input.carriesMarker?.(currentKey) ?? true));
+    // A function has no comment, so nothing to restamp: it never carries the marker.
+    const restamp =
+      obj.type !== CLICKHOUSE_ENTITY_TYPES.function && !stepsSetComment(obj, mine) && (mine.some((c) => c.field === "comment") || !(input.carriesMarker?.(currentKey) ?? true));
     const steps = [
       ...alterSteps(obj, mine, { ...(live ? { live } : {}), ...(input.marker ? { marker: input.marker } : {}) }),
       ...(restamp ? [stepFor(commentStatement(obj, input.marker), "SQLCH203")] : []),
@@ -519,8 +614,10 @@ function planDeclared(input: StatementPlanInput): StatementPlan {
     if (c.rule !== "SQLCH250") continue;
     const o = input.current.get(c.object);
     if (!o) continue;
+    // A function and access control carry no marker, so chant never drops one.
+    if (NEVER_DROPPED.has(o.kind)) continue;
     const type = CLICKHOUSE_ENTITY_TYPES[o.kind as keyof typeof CLICKHOUSE_ENTITY_TYPES];
-    const database = o.kind === "database" ? undefined : o.database;
+    const database = o.kind === "database" || o.kind === "function" ? undefined : o.database;
     drops.push({ key: c.object, type, ...(database !== undefined ? { database } : {}), name: o.name, step: stepFor(dropStatement(type, database, o.name), "SQLCH250") });
   }
   drops.sort((a, b) => (DROP_ORDER[kindOf(a.type)] ?? 9) - (DROP_ORDER[kindOf(b.type)] ?? 9));

package/src/clickhouse/dictionary.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Dictionaries (#3682): the `dictionary` tag, the declaration and the
+ * server's `SHOW CREATE` compared equal, every change but a comment
+ * replacing the dictionary (SQLCH245), and the statements for each
+ * topology. `live/dictionaries.e2e.test.ts` runs them against a server.
+ */
+
+import { describe, expect, test } from "vitest";
+import { dictionary, table, CLICKHOUSE_ENTITY_TYPES } from "./entities";
+import { canonicalObject, canonicalDictionaryClause, canonicalLifetime } from "./plan/normalize";
+import { diffSchemas } from "./plan/diff";
+import { CLASSIFIER_RULES } from "./plan/rules";
+import { alterSteps, createStatement, dropStatement, planStatements, type DeclaredObject } from "./apply/statements";
+import { renderStatement } from "./topology";
+import { SqlTemplateError } from "../core/template";
+
+const DECLARED = `CREATE DICTIONARY shop.rates_dict (
+  code String,
+  rate Float64 DEFAULT 1,
+  label String DEFAULT '' EXPRESSION upper(code) INJECTIVE
+)
+PRIMARY KEY code
+SOURCE(clickhouse(table 'rates' db 'shop' password 'secret'))
+LAYOUT(complex_key_hashed())
+LIFETIME(300)
+COMMENT 'exchange rates'`;
+
+// What clickhouse-server 26.8.15.10 prints for DECLARED.
+const SHOWN = `CREATE DICTIONARY shop.rates_dict
+(
+    \`code\` String,
+    \`rate\` Float64 DEFAULT 1,
+    \`label\` String DEFAULT '' EXPRESSION upper(code) INJECTIVE
+)
+PRIMARY KEY code
+SOURCE(CLICKHOUSE(TABLE 'rates' DB 'shop' PASSWORD '[HIDDEN]'))
+LIFETIME(MIN 0 MAX 300)
+LAYOUT(COMPLEX_KEY_HASHED())
+COMMENT 'exchange rates'`;
+
+const declared = (ddl: string, exportName = "ratesDict"): DeclaredObject => {
+  const canonical = canonicalObject(ddl);
+  return { exportName, type: CLICKHOUSE_ENTITY_TYPES.dictionary, key: `${canonical.database}.${canonical.name}`, ddl, canonical, dependsOn: [] };
+};
+
+describe("the dictionary tag", () => {
+  test("parses attributes, key, source, layout, lifetime and comment into props", () => {
+    const d = dictionary([DECLARED] as unknown as TemplateStringsArray);
+    expect(d.entityType).toBe("ClickHouse::Dictionary");
+    expect(d.sqlName).toBe("shop.rates_dict");
+    expect(d.props).toMatchObject({
+      name: "rates_dict",
+      database: "shop",
+      primaryKey: "code",
+      dataSource: "clickhouse(table 'rates' db 'shop' password 'secret')",
+      layout: "complex_key_hashed()",
+      lifetime: "300",
+      comment: "exchange rates",
+      columns: [
+        { name: "code", type: "String" },
+        { name: "rate", type: "Float64", default: "1" },
+        { name: "label", type: "String", default: "''", expression: "upper(code)", flags: ["INJECTIVE"] },
+      ],
+    });
+    expect(Object.keys(d.columns)).toEqual(["code", "rate", "label"]);
+  });
+
+  test("a range layout with its columns referenced, and settings", () => {
+    const rates = table`CREATE TABLE shop.rates (code String, rate Float64, start Date, end Date) ENGINE = MergeTree ORDER BY code`;
+    const d = dictionary`CREATE DICTIONARY shop.rates_by_day (code String, start Date, end Date, rate Float64)
+      PRIMARY KEY code SOURCE(CLICKHOUSE(TABLE 'rates' DB 'shop')) LAYOUT(COMPLEX_KEY_RANGE_HASHED())
+      RANGE(MIN ${rates.columns.start} MAX ${rates.columns.end}) LIFETIME(MIN 10 MAX 20) SETTINGS(format_csv_allow_single_quotes = 0)`;
+    expect(d.props.range).toBe("MIN start MAX end");
+    expect(d.props.settings).toEqual({ format_csv_allow_single_quotes: "0" });
+    expect(d.props.dataSource).toBe("CLICKHOUSE(TABLE 'rates' DB 'shop')");
+  });
+
+  test("a dictionary needs a key, a source and a layout; another statement names its tag", () => {
+    expect(() => dictionary(["CREATE DICTIONARY d (id UInt64) SOURCE(NULL()) LAYOUT(FLAT())"] as unknown as TemplateStringsArray)).toThrow(/PRIMARY KEY/);
+    expect(() => dictionary(["CREATE DICTIONARY d (id UInt64) PRIMARY KEY id LAYOUT(FLAT())"] as unknown as TemplateStringsArray)).toThrow(/SOURCE/);
+    expect(() => dictionary(["CREATE TABLE t (id UInt64) ENGINE = Memory"] as unknown as TemplateStringsArray)).toThrow(SqlTemplateError);
+    expect(() => table(["CREATE DICTIONARY d (id UInt64) PRIMARY KEY id SOURCE(NULL()) LAYOUT(FLAT())"] as unknown as TemplateStringsArray)).toThrow(/use the dictionary tag/);
+  });
+});
+
+describe("a dictionary compared with the server's", () => {
+  test("the declaration and what the server prints for it compare equal", () => {
+    expect(diffSchemas([{ key: "d", canonical: canonicalObject(SHOWN) }], [{ key: "d", canonical: canonicalObject(DECLARED) }]).changes).toEqual([]);
+  });
+
+  test("the server's rewrites are undone: key words upper case, a password hidden, a lifetime as MIN and MAX", () => {
+    expect(canonicalDictionaryClause("clickhouse(table src db 'x' user 'u' password 'p')")).toBe("CLICKHOUSE ( TABLE src DB 'x' USER 'u' PASSWORD '[HIDDEN]' )");
+    expect(canonicalDictionaryClause("hashed")).toBe("HASHED");
+    expect(canonicalDictionaryClause("flat(initial_array_size 100)")).toBe("FLAT ( INITIAL_ARRAY_SIZE 100 )");
+    expect(canonicalLifetime("300")).toBe("MIN 0 MAX 300");
+    expect(canonicalLifetime("max 20 min 10")).toBe("MIN 10 MAX 20");
+  });
+
+  test("every change but the comment replaces the dictionary (SQLCH245)", () => {
+    const before = canonicalObject(SHOWN);
+    const after = canonicalObject(
+      DECLARED.replace("complex_key_hashed()", "complex_key_sparse_hashed()").replace("LIFETIME(300)", "LIFETIME(600)").replace("rate Float64 DEFAULT 1", "rate Float64 DEFAULT 0").replace("'exchange rates'", "'rates'"),
+    );
+    const changes = diffSchemas([{ key: "d", canonical: before }], [{ key: "d", canonical: after }]).changes;
+    expect(changes.map((c) => [c.field, c.rule])).toEqual([
+      ["comment", "SQLCH203"],
+      ["columns.rate", "SQLCH245"],
+      ["layout", "SQLCH245"],
+      ["lifetime", "SQLCH245"],
+    ]);
+    expect(CLASSIFIER_RULES.SQLCH245.class).toBe("metadata");
+  });
+});
+
+describe("a dictionary's statements", () => {
+  const marker = { stack: "shop", env: "prod" };
+
+  test("created with chant's marker in its comment, replaced whole, dropped and renamed as a dictionary", () => {
+    const obj = declared(DECLARED);
+    expect(createStatement(obj, marker)).toMatch(/^CREATE DICTIONARY shop\.rates_dict[\s\S]*COMMENT 'exchange rates \[chant[^']*stack=shop env=prod[^']*\]'$/);
+    const changes = diffSchemas([{ key: obj.key, canonical: canonicalObject(SHOWN) }], [{ key: obj.key, canonical: canonicalObject(DECLARED.replace("LIFETIME(300)", "LIFETIME(600)")) }]).changes;
+    const plan = planStatements({ declared: [declared(DECLARED.replace("LIFETIME(300)", "LIFETIME(600)"))], changes, current: new Map([[obj.key, canonicalObject(SHOWN)]]), marker });
+    const entry = plan.objects[0]!;
+    expect(entry.verdict).toBe("alter");
+    const steps = entry.verdict === "alter" ? entry.steps : [];
+    expect(steps.map((s) => s.rule)).toEqual(["SQLCH245"]);
+    expect(steps[0]!.sql).toMatch(/^CREATE OR REPLACE DICTIONARY shop\.rates_dict[\s\S]*LIFETIME\(600\)[\s\S]*stack=shop/);
+    expect(dropStatement(CLICKHOUSE_ENTITY_TYPES.dictionary, "shop", "rates_dict")).toBe("DROP DICTIONARY `shop`.`rates_dict` SYNC");
+    const renamed = alterSteps(obj, [{ object: obj.key, field: "name", rule: "SQLCH230", class: "metadata", before: "shop.old_rates", after: "shop.rates_dict" } as never]);
+    expect(renamed.map((s) => s.sql)).toEqual(["RENAME DICTIONARY `shop`.`old_rates` TO `shop`.`rates_dict`"]);
+  });
+
+  test("a comment alone is restamped with ALTER, not replaced", () => {
+    const obj = declared(DECLARED.replace("'exchange rates'", "'rates'"));
+    const changes = diffSchemas([{ key: obj.key, canonical: canonicalObject(SHOWN) }], [{ key: obj.key, canonical: obj.canonical }]).changes;
+    const plan = planStatements({ declared: [obj], changes, current: new Map([[obj.key, canonicalObject(SHOWN)]]), marker });
+    const entry = plan.objects[0]!;
+    expect(entry.verdict === "alter" ? entry.steps.map((s) => s.sql) : []).toEqual([expect.stringMatching(/^ALTER TABLE `shop`\.`rates_dict` MODIFY COMMENT 'rates \[chant/)]);
+  });
+
+  test("ON CLUSTER on a cluster, none in a Replicated database or on a single node", () => {
+    const sql = createStatement(declared(DECLARED), marker);
+    expect(renderStatement(sql, { kind: "cluster", cluster: "main" })).toMatch(/^CREATE DICTIONARY shop\.rates_dict ON CLUSTER `main`\s*\(/);
+    expect(renderStatement(sql, { kind: "replicated", cluster: "main" })).not.toMatch(/ON CLUSTER/);
+    expect(renderStatement(sql, { kind: "single" })).toBe(sql);
+    expect(renderStatement(dropStatement(CLICKHOUSE_ENTITY_TYPES.dictionary, "shop", "rates_dict"), { kind: "cluster", cluster: "main" })).toBe(
+      "DROP DICTIONARY `shop`.`rates_dict` ON CLUSTER `main` SYNC",
+    );
+  });
+
+  test("dropped before the tables it reads, after the views", () => {
+    const current = new Map([
+      ["shop.rates", canonicalObject("CREATE TABLE shop.rates (code String) ENGINE = MergeTree ORDER BY code")],
+      ["shop.rates_dict", canonicalObject(SHOWN)],
+      ["shop.v", canonicalObject("CREATE VIEW shop.v AS SELECT dictGet('shop.rates_dict', 'rate', 'x')")],
+    ]);
+    const changes = diffSchemas([...current].map(([key, canonical]) => ({ key, canonical })), []).changes;
+    const plan = planStatements({ declared: [], changes, current, allowDestructive: true });
+    expect(plan.drops.map((d) => d.key)).toEqual(["shop.v", "shop.rates_dict", "shop.rates"]);
+  });
+});
+
+describe("importing a dictionary", () => {
+  test("the server's statement becomes a dictionary declaration that builds the same dictionary", async () => {
+    const { ClickHouseSqlParser } = await import("./import/parser");
+    const { ClickHouseGenerator } = await import("./import/generator");
+    const ir = new ClickHouseSqlParser().parse(`CREATE DATABASE shop;\n${SHOWN};`);
+    expect(ir.resources.map((r) => [r.logicalId, r.type])).toEqual([
+      ["shopDb", "ClickHouse::Database"],
+      ["ratesDict", "ClickHouse::Dictionary"],
+    ]);
+    const [file] = new ClickHouseGenerator().generate(ir);
+    expect(file!.content).toContain('import { database, dictionary } from "@intentius/chant-lexicon-sql/clickhouse";');
+    expect(file!.content).toContain("export const ratesDict = dictionary`");
+    expect(file!.content).toContain("CREATE DICTIONARY ${shopDb}.rates_dict");
+  });
+});