@intentius/chant-lexicon-sql 0.124.19 → 0.124.21

package/src/core/undeclarable.test.ts

@@ -29,10 +29,10 @@ const CATALOG: FakeCatalog = {
   schemas: [{ name: "app" }],
   tables: [{ schema: "app", name: "users", columns: [{ name: "id", type: "bigint", notnull: true }] }],
   undeclarable: [
-    { kind: "aggregate", schema: "app", name: "total(integer)" },
-    { kind: "cast", name: "(app.pair AS text)" },
-    { kind: "composite type", schema: "app", name: "pair" },
-    { kind: "event trigger", name: "audit_ddl" },
+    { kind: "access method", name: "heap2" },
+    { kind: "conversion", schema: "app", name: "latin1_utf8" },
+    { kind: "rule", schema: "app", name: "users_notify ON users" },
+    { kind: "base type", schema: "app", name: "later" },
   ],
 };
 
@@ -45,10 +45,10 @@ describe("Postgres live import", () => {
     );
     expect(err).toBeInstanceOf(UndeclarableObjectsError);
     const message = (err as Error).message;
-    for (const line of ["  - aggregate app.total(integer)", "  - cast (app.pair AS text)", "  - composite type app.pair", "  - event trigger audit_ddl"]) {
+    for (const line of ["  - access method heap2", "  - conversion app.latin1_utf8", "  - rule app.users_notify ON users", "  - base type app.later"]) {
       expect(message).toContain(line);
     }
-    expect(message).toContain("  - aggregate: no tag declares an aggregate yet");
+    expect(message).toContain("  - conversion: no tag declares an encoding conversion");
     expect(message).toContain("--skip-undeclarable");
   });
 
@@ -58,7 +58,7 @@ describe("Postgres live import", () => {
     expect(ir.resources.map((r) => r.properties.name)).toContain("users");
     const left = (ir.warnings ?? []).filter((w) => w.includes("is left out (--skip-undeclarable)"));
     expect(left).toHaveLength(4);
-    expect(left[0]).toBe("aggregate app.total(integer) is left out (--skip-undeclarable): no tag declares an aggregate yet");
+    expect(left[0]).toBe("access method heap2 is left out (--skip-undeclarable): no tag declares an access method; an extension usually installs one, and the extension is declared instead");
   });
 
   test("a selector or owned import does not look", async () => {
@@ -68,11 +68,11 @@ describe("Postgres live import", () => {
   });
 
   test("a managed provider's own objects are its, with a warning, not a refusal", async () => {
-    pg.catalog = { ...CATALOG, undeclarable: [{ kind: "aggregate", schema: "auth", name: "x(integer)" }] };
+    pg.catalog = { ...CATALOG, undeclarable: [{ kind: "conversion", schema: "auth", name: "x" }] };
     pg.provider = "supabase";
     try {
       const ir = await exportPostgres({ environment: "prod" });
-      expect(ir.warnings).toContain("aggregate auth.x(integer) is kept by Supabase; left out");
+      expect(ir.warnings).toContain("conversion auth.x is kept by Supabase; left out");
     } finally {
       pg.provider = undefined;
     }
@@ -90,8 +90,8 @@ describe("ClickHouse live import", () => {
       ],
       {
         undeclarable: [
-          { kind: "quota", name: "q1" },
-          { kind: "settings profile", name: "sp1" },
+          { kind: "named collection", name: "nc1" },
+          { kind: "workload", name: "all" },
           { kind: "window view", database: "analytics", name: "wv" },
         ],
       },
@@ -101,7 +101,7 @@ describe("ClickHouse live import", () => {
   const run = (extra: Record<string, unknown> = {}) => exportClickHouse({ environment: "x", config: {}, env: { CLICKHOUSE_URL: server.url }, ...extra });
 
   test("fails naming them", async () => {
-    await expect(run()).rejects.toThrow(/  - quota q1\n  - settings profile sp1\n  - window view analytics\.wv\n/);
+    await expect(run()).rejects.toThrow(/  - named collection nc1\n  - window view analytics\.wv\n  - workload all\n/);
   });
 
   test("with skipUndeclarable, warns, and the window view is not imported as a table", async () => {
@@ -115,24 +115,27 @@ describe("file import", () => {
   const DDL = `CREATE SCHEMA app;
 CREATE TABLE app.t (id int PRIMARY KEY);
 CREATE AGGREGATE app.total(int) (sfunc = int4pl, stype = int);
+CREATE CONVERSION app.latin1_utf8 FOR 'LATIN1' TO 'UTF8' FROM iso8859_1_to_utf8;
 CREATE TYPE app.pair AS (a int, b text);
+CREATE TYPE app.later;
 CREATE COLLATION app.ci (provider = icu, locale = 'und');`;
 
   test("a CREATE of a kind chant cannot declare is an error naming it", () => {
-    expect(() => new SqlFileParser("postgres").parse(DDL)).toThrow(/aggregate: chant cannot declare it \(no tag declares an aggregate yet\): CREATE AGGREGATE app\.total/);
+    expect(() => new SqlFileParser("postgres").parse(DDL)).toThrow(/conversion: chant cannot declare it \(no tag declares an encoding conversion\): CREATE CONVERSION app\.latin1_utf8/);
   });
 
   test("skipUndeclarable imports the rest and lists them as warnings", () => {
     const ir = new SqlFileParser("postgres", { skipUndeclarable: true }).parse(DDL);
-    expect(ir.resources.map((r) => r.properties.name)).toEqual(["app", "t"]);
+    // An aggregate, a composite type and a collation are declared kinds (#3911): imported, not refused.
+    expect(ir.resources.map((r) => r.properties.name)).toEqual(["app", "t", "total", "pair", "ci"]);
     expect(ir.warnings).toEqual([
-      "left out (skipUndeclarable): aggregate: chant cannot declare it (no tag declares an aggregate yet): CREATE AGGREGATE app.total(int) (sfunc = int4pl, stype = int)",
-      "left out (skipUndeclarable): composite type: chant cannot declare it (no tag declares a composite type yet): CREATE TYPE app.pair AS (a int, b text)",
-      "left out (skipUndeclarable): collation: chant cannot declare it (no tag declares a collation yet): CREATE COLLATION app.ci (provider = icu, locale = 'und')",
+      "left out (skipUndeclarable): conversion: chant cannot declare it (no tag declares an encoding conversion): CREATE CONVERSION app.latin1_utf8 FOR 'LATIN1' TO 'UTF8' FROM iso8859_1_to_utf8",
+      "left out (skipUndeclarable): base type: chant cannot declare it (no tag declares a base type; its input and output functions are C code an extension installs): CREATE TYPE app.later",
     ]);
   });
 
-  test("ClickHouse: a quota in a file is refused too", () => {
-    expect(() => new SqlFileParser("clickhouse").parse("CREATE DATABASE a;\nCREATE QUOTA q1")).toThrow(/quota: chant cannot declare it/);
+  test("ClickHouse: a named collection in a file is refused too; a quota is declared (#3911)", () => {
+    expect(() => new SqlFileParser("clickhouse").parse("CREATE DATABASE a;\nCREATE NAMED COLLECTION c AS url = 'x'")).toThrow(/named collection: chant cannot declare it/);
+    expect(new SqlFileParser("clickhouse").parse("CREATE DATABASE a;\nCREATE QUOTA q1").resources.map((r) => r.type)).toEqual(["ClickHouse::Database", "ClickHouse::Quota"]);
   });
 });

package/src/coverage/clickhouse.json

@@ -5,21 +5,21 @@
     { "command": "CREATE DICTIONARY", "kind": "dictionary", "status": "declared", "entity": "ClickHouse::Dictionary" },
     { "command": "CREATE FUNCTION", "kind": "SQL function", "status": "declared", "entity": "ClickHouse::Function" },
     { "command": "CREATE FUNCTION", "form": "LANGUAGE WASM, or with a driver", "match": "\\bLANGUAGE\\b|\\bUSING\\s+DRIVER\\b", "kind": "non-SQL function", "status": "refused", "reason": "only a SQL function (CREATE FUNCTION f AS (x) -> ...) is declared" },
-    { "command": "CREATE HANDLER", "kind": "HTTP handler", "status": "refused", "reason": "no declaration holds an HTTP handler yet" },
+    { "command": "CREATE HANDLER", "kind": "HTTP handler", "status": "refused", "reason": "an HTTP handler is server-level configuration, not a schema object" },
     { "command": "CREATE INDEX", "kind": "index", "status": "declared", "entity": "ClickHouse::Table", "note": "an index is part of its table: SHOW CREATE TABLE prints it, and the table's declaration holds it" },
-    { "command": "CREATE MASKING POLICY", "kind": "masking policy", "status": "refused", "reason": "no declaration holds a masking policy yet" },
-    { "command": "CREATE NAMED COLLECTION", "kind": "named collection", "status": "refused", "reason": "no declaration holds a named collection yet; one usually carries credentials" },
-    { "command": "CREATE QUOTA", "kind": "quota", "status": "refused", "reason": "no declaration holds a quota yet" },
-    { "command": "CREATE RESOURCE", "kind": "workload resource", "status": "refused", "reason": "no declaration holds a workload scheduling resource yet" },
+    { "command": "CREATE MASKING POLICY", "kind": "masking policy", "status": "refused", "reason": "masking policies are available only in ClickHouse Cloud, not on the pinned server" },
+    { "command": "CREATE NAMED COLLECTION", "kind": "named collection", "status": "refused", "reason": "a named collection holds credentials (a password, a secret key), which are the environment's and never in a build; the server hides its values, so a plan could not compare them either" },
+    { "command": "CREATE QUOTA", "kind": "quota", "status": "declared", "entity": "ClickHouse::Quota", "note": "import reads only the access objects a build declares" },
+    { "command": "CREATE RESOURCE", "kind": "workload resource", "status": "refused", "reason": "a resource is server-level scheduling (a disk's reads or writes), configured with the server, not a schema object" },
     { "command": "CREATE ROLE", "kind": "role", "status": "declared", "entity": "ClickHouse::Role", "note": "import reads only the access objects a build declares" },
     { "command": "CREATE ROW POLICY", "kind": "row policy", "status": "declared", "entity": "ClickHouse::RowPolicy", "note": "import reads only the access objects a build declares" },
-    { "command": "CREATE SETTINGS PROFILE", "kind": "settings profile", "status": "refused", "reason": "no declaration holds a settings profile yet" },
+    { "command": "CREATE SETTINGS PROFILE", "kind": "settings profile", "status": "declared", "entity": "ClickHouse::SettingsProfile", "note": "import reads only the access objects a build declares" },
     { "command": "CREATE TABLE", "kind": "table", "status": "declared", "entity": "ClickHouse::Table" },
     { "command": "CREATE TABLE", "form": "TEMPORARY", "match": "^CREATE\\s+TEMPORARY\\b", "kind": "temporary table", "status": "out-of-scope", "reason": "a temporary table lives in one session" },
     { "command": "CREATE USER", "kind": "user", "status": "declared", "entity": "ClickHouse::User", "note": "import reads only the access objects a build declares" },
     { "command": "CREATE VIEW", "kind": "view", "status": "declared", "entity": "ClickHouse::View" },
     { "command": "CREATE VIEW", "form": "MATERIALIZED", "match": "^CREATE\\s+(?:OR\\s+REPLACE\\s+)?MATERIALIZED\\b", "kind": "materialized view", "status": "declared", "entity": "ClickHouse::MaterializedView" },
-    { "command": "CREATE WINDOW VIEW", "kind": "window view", "status": "refused", "reason": "no declaration holds a window view, an experimental feature" },
-    { "command": "CREATE WORKLOAD", "kind": "workload", "status": "refused", "reason": "no declaration holds a workload yet" }
+    { "command": "CREATE WINDOW VIEW", "kind": "window view", "status": "refused", "reason": "a window view is experimental, and the pinned server refuses it under its default query analyzer" },
+    { "command": "CREATE WORKLOAD", "kind": "workload", "status": "refused", "reason": "a workload is server-level scheduling, configured with the server, not a schema object" }
   ]
 }

package/src/coverage/postgres.json

@@ -2,13 +2,13 @@
   "dialect": "postgres",
   "kinds": [
     { "command": "CREATE ACCESS METHOD", "kind": "access method", "status": "refused", "reason": "no tag declares an access method; an extension usually installs one, and the extension is declared instead" },
-    { "command": "CREATE AGGREGATE", "kind": "aggregate", "status": "refused", "reason": "no tag declares an aggregate yet" },
-    { "command": "CREATE CAST", "kind": "cast", "status": "refused", "reason": "no tag declares a cast yet" },
-    { "command": "CREATE COLLATION", "kind": "collation", "status": "refused", "reason": "no tag declares a collation yet" },
+    { "command": "CREATE AGGREGATE", "kind": "aggregate", "status": "declared", "entity": "Postgres::Aggregate" },
+    { "command": "CREATE CAST", "kind": "cast", "status": "declared", "entity": "Postgres::Cast", "note": "the database's, named by its two types; read where a type or its function is in scope" },
+    { "command": "CREATE COLLATION", "kind": "collation", "status": "declared", "entity": "Postgres::Collation" },
     { "command": "CREATE CONVERSION", "kind": "conversion", "status": "refused", "reason": "no tag declares an encoding conversion" },
     { "command": "CREATE DATABASE", "kind": "database", "status": "out-of-scope", "reason": "a project's schema lives in one database, which the environment provides (sql.profiles.<env>)" },
     { "command": "CREATE DOMAIN", "kind": "domain", "status": "declared", "entity": "Postgres::Domain" },
-    { "command": "CREATE EVENT TRIGGER", "kind": "event trigger", "status": "refused", "reason": "no tag declares an event trigger yet" },
+    { "command": "CREATE EVENT TRIGGER", "kind": "event trigger", "status": "declared", "entity": "Postgres::EventTrigger", "note": "the database's, not a schema's; creating one takes a superuser" },
     { "command": "CREATE EXTENSION", "kind": "extension", "status": "declared", "entity": "Postgres::Extension" },
     { "command": "CREATE FOREIGN DATA WRAPPER", "kind": "foreign data wrapper", "status": "refused", "reason": "no tag declares a foreign data wrapper yet; one an extension installs comes with the extension" },
     { "command": "CREATE FOREIGN TABLE", "kind": "foreign table", "status": "refused", "reason": "no tag declares a foreign table yet" },
@@ -41,8 +41,8 @@
     { "command": "CREATE TRANSFORM", "kind": "transform", "status": "refused", "reason": "no tag declares a transform; an extension installs one" },
     { "command": "CREATE TRIGGER", "kind": "trigger", "status": "declared", "entity": "Postgres::Trigger" },
     { "command": "CREATE TYPE", "form": "AS ENUM", "match": "\\bAS\\s+ENUM\\b", "kind": "enum type", "status": "declared", "entity": "Postgres::Enum" },
-    { "command": "CREATE TYPE", "form": "AS (...)", "match": "\\bAS\\s*\\(", "kind": "composite type", "status": "refused", "reason": "no tag declares a composite type yet" },
-    { "command": "CREATE TYPE", "form": "AS RANGE", "match": "\\bAS\\s+RANGE\\b", "kind": "range type", "status": "refused", "reason": "no tag declares a range type yet" },
+    { "command": "CREATE TYPE", "form": "AS (...)", "match": "\\bAS\\s*\\(", "kind": "composite type", "status": "declared", "entity": "Postgres::CompositeType" },
+    { "command": "CREATE TYPE", "form": "AS RANGE", "match": "\\bAS\\s+RANGE\\b", "kind": "range type", "status": "declared", "entity": "Postgres::RangeType", "note": "its multirange type comes with it (MULTIRANGE_TYPE_NAME)" },
     { "command": "CREATE TYPE", "form": "INPUT, OUTPUT, or a shell type", "kind": "base type", "status": "refused", "reason": "no tag declares a base type; its input and output functions are C code an extension installs" },
     { "command": "CREATE USER", "kind": "user", "status": "declared", "entity": "Postgres::Role", "note": "an alias of CREATE ROLE ... LOGIN" },
     { "command": "CREATE USER MAPPING", "kind": "user mapping", "status": "refused", "reason": "no tag declares a user mapping yet" },

package/src/files/clickhouse.ts

@@ -2,7 +2,8 @@
  * A file of ClickHouse DDL as the objects it declares: one per `CREATE
  * DATABASE`, `TABLE`, `VIEW`, `MATERIALIZED VIEW`, `DICTIONARY` or `FUNCTION`, as `chant import
  * <file>.sql` reads them, and one per `CREATE USER`, `CREATE ROLE`, `CREATE
- * ROW POLICY` and `GRANT` (#3711), each read by its tag, so what the tag
+ * ROW POLICY`, `CREATE QUOTA`, `CREATE SETTINGS PROFILE` (#3911) and `GRANT`
+ * (#3711), each read by its tag, so what the tag
  * refuses (`IDENTIFIED BY`, a `REVOKE`) is refused with the tag's message.
  * Any other statement, and any statement the parser refuses, is a problem
  * naming it.
@@ -15,7 +16,7 @@
 import type { Declarable } from "@intentius/chant/declarable";
 import { isTrivia, tokenizeText } from "../clickhouse/tokens";
 import { parseCreate } from "../clickhouse/parser";
-import { CLICKHOUSE_ENTITY_TYPES, database, dictionary, func, grant, policy, role, table, user, view } from "../clickhouse/entities";
+import { CLICKHOUSE_ENTITY_TYPES, database, dictionary, func, grant, policy, quota, role, settingsProfile, table, user, view } from "../clickhouse/entities";
 import { isAccessStatement, parseAccess, type AccessNode } from "../clickhouse/access";
 import type { Token } from "../clickhouse/tokens";
 import { CLICKHOUSE_TAG_OF } from "../clickhouse/import/generator";
@@ -24,7 +25,13 @@ import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, un
 import { templateSafe, templateStrings } from "./postgres";
 
 type Tag = (strings: TemplateStringsArray, ...values: unknown[]) => Declarable;
-const TAGS: Record<string, Tag> = { database, table, view, dictionary, func, user, role, policy, grant };
+const TAGS: Record<string, Tag> = { database, table, view, dictionary, func, user, role, policy, quota, settingsProfile, grant };
+
+/** The tag an access statement's words name: `CREATE USER`, `CREATE SETTINGS PROFILE`, `GRANT`. */
+function accessTag(words: string[]): Tag {
+  if (words[0] !== "CREATE") return grant;
+  return words[1] === "USER" ? user : words[1] === "ROLE" ? role : words[1] === "QUOTA" ? quota : words[1] === "SETTINGS" || words[1] === "PROFILE" ? settingsProfile : policy;
+}
 
 /** Tokens with `[db.]name`'s bare name qualified with `schema`. A `*` (all tables) is left alone. */
 function qualifyBare(tokens: Token[], span: { from: number; to: number } | undefined, schema: string): string | undefined {
@@ -44,8 +51,7 @@ function readAccess(sql: string, options: ReadOptions): ImportedObject | string
     node = parseAccess(tokens);
   } catch (e) {
     // What the tag refuses (a password) is refused in the tag's words.
-    const words = sql.replace(/--[^\n]*\n/g, " ").trim().split(/\s+/, 2).map((w) => w.toUpperCase());
-    const tag = words[0] === "CREATE" ? (words[1] === "USER" ? user : words[1] === "ROLE" ? role : policy) : grant;
+    const tag = accessTag(sql.replace(/--[^\n]*\n/g, " ").trim().split(/\s+/, 2).map((w) => w.toUpperCase()));
     try {
       tag(templateStrings([templateSafe(sql)]));
     } catch (refused) {
@@ -61,7 +67,7 @@ function readAccess(sql: string, options: ReadOptions): ImportedObject | string
       node = parseAccess(tokens);
     }
   }
-  const tag = node.statement === "user" ? user : node.statement === "role" ? role : node.statement === "rowPolicy" ? policy : grant;
+  const tag = { user, role, rowPolicy: policy, quota, settingsProfile, grant }[node.statement];
   let props: { name: string; database?: string; table?: string };
   try {
     props = (tag(templateStrings([templateSafe(sql)])) as unknown as { props: typeof props }).props;
@@ -70,6 +76,8 @@ function readAccess(sql: string, options: ReadOptions): ImportedObject | string
   }
   if (node.statement === "user") return { type: CLICKHOUSE_ENTITY_TYPES.user, name: props.name, ddl: sql };
   if (node.statement === "role") return { type: CLICKHOUSE_ENTITY_TYPES.role, name: props.name, ddl: sql };
+  if (node.statement === "quota") return { type: CLICKHOUSE_ENTITY_TYPES.quota, name: props.name, ddl: sql };
+  if (node.statement === "settingsProfile") return { type: CLICKHOUSE_ENTITY_TYPES.settingsProfile, name: props.name, ddl: sql };
   if (node.statement === "rowPolicy") return { type: CLICKHOUSE_ENTITY_TYPES.rowPolicy, ...(props.database ? { database: props.database } : {}), name: props.name, ddl: sql };
   // A grant has no name of its own: what it grants, on what, to whom.
   return { type: CLICKHOUSE_ENTITY_TYPES.grant, name: `grant ${tokensText(tokens.slice(tokens.findIndex((t) => !isTrivia(t)) + 1)).replace(/\s+/g, " ").trim().toLowerCase()}`, ddl: sql };

package/src/files/postgres.ts

@@ -16,12 +16,12 @@
  * With `schema`, the names the DDL leaves unqualified are qualified with it,
  * as an ORM's connection would: an object's own name, an index's, trigger's
  * or policy's table, a foreign key's table, a comment's target, and a column
- * type naming an enum or domain the file creates.
+ * type naming an enum, composite, range or domain type the file creates.
  */
 
 import type { Declarable } from "@intentius/chant/declarable";
 import { isTrivia, tokenizeText, type Token } from "../postgres/tokens";
-import { identValue, parseStatements, type NameNode, type StatementNode } from "../postgres/parser";
+import { identValue, parseStatements, type NameNode, type Span, type StatementNode } from "../postgres/parser";
 import * as tags from "../postgres/entities";
 import { POSTGRES_ENTITY_TYPES, type PostgresEntityType } from "../postgres/entity-types";
 import { POSTGRES_TAG_OF } from "../postgres/import/generator";
@@ -117,7 +117,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
   // The types the file creates, so a column of one is qualified with the rest.
   const fileTypes = new Set<string>();
   for (const { tokens, node } of parsed) {
-    if (node.statement === "enum" || node.statement === "domain") {
+    if (node.statement === "enum" || node.statement === "domain" || node.statement === "composite" || node.statement === "range") {
       const pieces = nameOf(tokens, node.name);
       if (pieces.length === 1) fileTypes.add(pieces[0]!);
     }
@@ -138,7 +138,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
     };
     switch (node.statement) {
       case "comment":
-        if (node.objectType !== "SCHEMA" && node.objectType !== "EXTENSION" && node.objectType !== "ROLE" && node.objectType !== "TRIGGER" && node.objectType !== "POLICY" && node.objectType !== "CONSTRAINT" && node.objectType !== "COLUMN") mark(node.target);
+        if (!["SCHEMA", "EXTENSION", "ROLE", "TRIGGER", "POLICY", "CONSTRAINT", "COLUMN", "CAST", "EVENT TRIGGER"].includes(node.objectType)) mark(node.target);
         if (node.objectType === "COLUMN" && nameOf(tokens, node.target).length === 2 && options.schema) {
           const first = tokens.slice(node.target.span.from, node.target.span.to).find((t) => !isTrivia(t));
           if (first) inserts.add(tokens.indexOf(first));
@@ -177,7 +177,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
       problems.push(`an index with no name (its declaration needs one): ${firstLine(tokensText(tokens))}`);
       continue;
     }
-    const ownName = !["schema", "extension", "index", "trigger", "policy", "role", "grant"].includes(node.statement);
+    const ownName = !["schema", "extension", "index", "trigger", "policy", "role", "grant", "cast", "eventTrigger"].includes(node.statement);
     if (ownName && "name" in node) mark(node.name);
     const object: PgFileObject = { node, statements: [rewrite(tokens, inserts, options.schema)], constraints: [], line, unparsed: fileUnparsed("unknown" in node ? node.unknown : undefined, tokens, tokensText(tokens), line) };
     objects.push(object);
@@ -277,6 +277,10 @@ function ownerKey(node: StatementNode, tokens: Token[], nameOf: NameOf, qualify:
     case "trigger":
     case "policy":
       return `${node.statement} ${nameOf(tokens, node.name).at(-1) ?? ""} ON ${qkey(qualify(nameOf(tokens, node.table)))}`;
+    case "eventTrigger":
+      return `eventTrigger ${nameOf(tokens, node.name).at(-1) ?? ""}`;
+    case "cast":
+      return `cast ${castKey(tokens, node.source, node.target)}`;
     case "grant":
     case "comment":
     case "rowSecurity":
@@ -305,6 +309,10 @@ function followOnOwner(node: StatementNode, tokens: Token[], nameOf: NameOf, qua
     case "TRIGGER":
     case "POLICY":
       return node.on ? `${node.objectType.toLowerCase()} ${target.at(-1) ?? ""} ON ${qkey(qualify(nameOf(tokens, node.on)))}` : undefined;
+    case "EVENT TRIGGER":
+      return `eventTrigger ${target.at(-1) ?? ""}`;
+    case "CAST":
+      return node.cast ? `cast ${castKey(tokens, node.cast.source, node.cast.target)}` : undefined;
     case "CONSTRAINT":
     case "DOMAIN CONSTRAINT":
       return node.on ? `rel ${qkey(qualify(nameOf(tokens, node.on)))}` : undefined;
@@ -313,6 +321,12 @@ function followOnOwner(node: StatementNode, tokens: Token[], nameOf: NameOf, qua
   }
 }
 
+/** A cast's two types as one key, spacing and case aside. */
+function castKey(tokens: readonly Token[], source: Span, target: Span): string {
+  const text = (sp: Span) => tokens.slice(sp.from, sp.to).filter((t) => !isTrivia(t)).map((t) => (t.kind === "ident" ? t.text.toLowerCase() : t.text)).join(" ");
+  return `(${text(source)} AS ${text(target)})`;
+}
+
 /** The statement's tokens with `schema.` inserted before each marked one. */
 function rewrite(tokens: readonly Token[], inserts: ReadonlySet<number>, schema: string | undefined): Token[] {
   if (!schema || inserts.size === 0) return [...tokens];

package/src/generated/lexicon-sql.json

@@ -49,6 +49,16 @@
     "kind": "resource",
     "lexicon": "sql"
   },
+  "Quota": {
+    "resourceType": "ClickHouse::Quota",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
+  "SettingsProfile": {
+    "resourceType": "ClickHouse::SettingsProfile",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
   "PostgresSchema": {
     "resourceType": "Postgres::Schema",
     "kind": "resource",
@@ -84,11 +94,41 @@
     "kind": "resource",
     "lexicon": "sql"
   },
+  "PostgresCompositeType": {
+    "resourceType": "Postgres::CompositeType",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
+  "PostgresRangeType": {
+    "resourceType": "Postgres::RangeType",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
   "PostgresDomain": {
     "resourceType": "Postgres::Domain",
     "kind": "resource",
     "lexicon": "sql"
   },
+  "PostgresAggregate": {
+    "resourceType": "Postgres::Aggregate",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
+  "PostgresCollation": {
+    "resourceType": "Postgres::Collation",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
+  "PostgresCast": {
+    "resourceType": "Postgres::Cast",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
+  "PostgresEventTrigger": {
+    "resourceType": "Postgres::EventTrigger",
+    "kind": "resource",
+    "lexicon": "sql"
+  },
   "PostgresExtension": {
     "resourceType": "Postgres::Extension",
     "kind": "resource",

package/src/index.ts

@@ -12,13 +12,13 @@ export { sqlConfigSchema, type SqlConfig } from "./config";
 // them as intrinsics (check-lexicon resolves a registered intrinsic against the
 // root's exports). Declarations import them from the dialect subpath,
 // `@intentius/chant-lexicon-sql/clickhouse`.
-export { database, table, view, dictionary, user, role, policy, grant, literal } from "./clickhouse/entities";
+export { database, table, view, dictionary, user, role, policy, quota, settingsProfile, grant, literal } from "./clickhouse/entities";
 
 // The Postgres tags whose names ClickHouse does not export, for the same reason.
 // A tag folds as the function its file imports, so `table` imported from
 // `@intentius/chant-lexicon-sql/postgres` is Postgres's. Declarations import
 // them from the dialect subpath.
-export { schema, index, sequence, type, domain, extension, func, procedure, trigger } from "./postgres/entities";
+export { schema, index, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, collation, cast } from "./postgres/entities";
 
 // A schema change's statements between two builds, rendered offline for a
 // migration file (#3644); also at `@intentius/chant-lexicon-sql/migration-statements`.

package/src/lint/post-synth/postgres-names.ts

@@ -137,11 +137,24 @@ export function projectFromObjects(objects: OutputObject[], major: number): PgPr
   };
 }
 
-const TYPE_OBJECTS = new Set(["Postgres::Enum", "Postgres::Domain", "Postgres::Table", "Postgres::View", "Postgres::MaterializedView"]);
+const TYPE_OBJECTS = new Set(["Postgres::Enum", "Postgres::CompositeType", "Postgres::RangeType", "Postgres::Domain", "Postgres::Table", "Postgres::View", "Postgres::MaterializedView"]);
 const ROUTINES = new Set(["Postgres::Function", "Postgres::Procedure"]);
 
+/** A range type's multirange type's name: as written (its last piece), else as Postgres derives it. */
+function multirangeOf(o: OutputObject): string | undefined {
+  if (o.type !== "Postgres::RangeType") return undefined;
+  const written = o.multirangeTypeName as string | undefined;
+  if (written) {
+    const last = written.split(".").pop()!.trim();
+    return /^"/.test(last) ? last.slice(1, -1).replace(/""/g, '"') : last.toLowerCase();
+  }
+  const name = String(o.name);
+  const at = name.indexOf("range");
+  return at >= 0 ? `${name.slice(0, at)}multi${name.slice(at)}` : `${name}_multirange`;
+}
+
 function declared(p: PgProject, kinds: ReadonlySet<string>, schema: string | undefined, name: string): OutputObject | undefined {
-  return p.objects.find((o) => kinds.has(o.type) && o.name === name && (schema === undefined || o.schema === schema));
+  return p.objects.find((o) => kinds.has(o.type) && (o.name === name || multirangeOf(o) === name) && (schema === undefined || o.schema === schema));
 }
 
 /** The extension that provides `name` in `section`, if the overlay knows one; declared ones first. */

package/src/lint/post-synth/sql101.ts

@@ -14,6 +14,7 @@ const NOT_UNIQUE = new Set([
   "Postgres::DefaultPrivileges",
   "Postgres::Function",
   "Postgres::Procedure",
+  "Postgres::Aggregate",
   "Postgres::Trigger",
   "Postgres::Policy",
 ]);

package/src/lint/post-synth/sqlpg113.ts

@@ -1,7 +1,7 @@
 import { checkOf } from "./postgres-helpers";
 import { postgresObjects } from "./sql-helpers";
 
-const PLACED = new Set(["Postgres::Table", "Postgres::View", "Postgres::MaterializedView", "Postgres::Sequence", "Postgres::Enum", "Postgres::Domain"]);
+const PLACED = new Set(["Postgres::Table", "Postgres::View", "Postgres::MaterializedView", "Postgres::Sequence", "Postgres::Enum", "Postgres::CompositeType", "Postgres::RangeType", "Postgres::Domain"]);
 
 /**
  * SQLPG113: an object in the public schema while the project declares schemas.

package/src/lint/rules/postgres-templates.ts

@@ -17,12 +17,12 @@ export const POSTGRES_TEMPLATE_SOURCES: readonly TemplateSource<PostgresTag>[] =
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql/postgres"],
-    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "trigger", "policy", "role", "grant"],
+    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
   },
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql"],
-    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "trigger", "policy", "role", "grant"],
+    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
   },
 ];
 

package/src/lint/rules/sqlch001.ts

@@ -4,15 +4,22 @@ import { parseAccess } from "../../clickhouse/access";
 import { SqlSyntaxError } from "../../clickhouse/tokens";
 import { findTemplates, templatePosition, tokensOf } from "./templates";
 
-const ACCESS_TAGS = new Set(["user", "role", "policy", "grant"]);
-const ACCESS_STATEMENT: Record<string, string> = { user: "CREATE USER", role: "CREATE ROLE", rowPolicy: "CREATE ROW POLICY", grant: "GRANT" };
+const ACCESS_TAGS = new Set(["user", "role", "policy", "quota", "settingsProfile", "grant"]);
+const ACCESS_STATEMENT: Record<string, string> = {
+  user: "CREATE USER",
+  role: "CREATE ROLE",
+  rowPolicy: "CREATE ROW POLICY",
+  quota: "CREATE QUOTA",
+  settingsProfile: "CREATE SETTINGS PROFILE",
+  grant: "GRANT",
+};
 
 const STATEMENT: Record<string, string> = { database: "CREATE DATABASE", table: "CREATE TABLE", view: "CREATE VIEW", dictionary: "CREATE DICTIONARY", function: "CREATE FUNCTION" };
 /** The tag a statement belongs in: `func` for a function, the statement's own name otherwise. */
 const tagOf = (statement: string): string => (statement === "function" ? "func" : statement);
 
 /**
- * SQLCH001: the DDL in a ClickHouse template (`database`, `table`, `view`, `dictionary`, `func`, `user`, `role`, `policy`, `grant`) does not parse, or holds another statement than its tag.
+ * SQLCH001: the DDL in a ClickHouse template (`database`, `table`, `view`, `dictionary`, `func`, `user`, `role`, `policy`, `quota`, `settingsProfile`, `grant`) does not parse, or holds another statement than its tag.
  *
  * The same parse runs when the build calls the tag, and fails the build there.
  * This rule reports it in the editor and in `chant lint`, at the token, before

package/src/lint/rules/sqlpg001.ts

@@ -1,27 +1,12 @@
 import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
 import { parseStatements, SqlSyntaxError } from "../../postgres/parser";
-import { followOnStray, STATEMENT_NAMES, type PostgresTag } from "../../postgres/entities";
+import { followOnStray, STATEMENT_NAMES, STATEMENTS_OF, type PostgresTag } from "../../postgres/entities";
 import { findPostgresTemplates, postgresTokensOf, templatePosition, tokenPosition } from "./postgres-templates";
 
-/** The statement each tag holds. */
-const STATEMENT: Record<PostgresTag, string> = {
-  schema: "schema",
-  table: "table",
-  index: "index",
-  view: "view",
-  sequence: "sequence",
-  type: "enum",
-  domain: "domain",
-  extension: "extension",
-  func: "function",
-  procedure: "procedure",
-  trigger: "trigger",
-  policy: "policy",
-  role: "role",
-  grant: "grant",
-};
-
-const TAG_OF: Record<string, PostgresTag> = Object.fromEntries(Object.entries(STATEMENT).map(([tag, statement]) => [statement, tag as PostgresTag]));
+/** The tag that declares each statement. */
+const TAG_OF: Record<string, PostgresTag> = Object.fromEntries(
+  Object.entries(STATEMENTS_OF).flatMap(([tag, statements]) => statements.map((statement) => [statement, tag as PostgresTag])),
+);
 
 /**
  * SQLPG001: the DDL in a Postgres template does not parse, or does not hold
@@ -60,7 +45,7 @@ export const sqlpg001: LintRule = {
       if (!tokens) continue;
       try {
         const [node, ...rest] = parseStatements(tokens);
-        if (node!.statement !== STATEMENT[found.tag]) {
+        if (!STATEMENTS_OF[found.tag].includes(node!.statement)) {
           const use = TAG_OF[node!.statement];
           report(
             use

package/src/lint/rules/templates.ts

@@ -13,7 +13,7 @@ import { findSqlTemplates, type FoundTemplate as SqlFoundTemplate, type Template
 
 export { templatePosition, tokenPosition } from "../../core/find-templates";
 
-export type SqlTag = "database" | "table" | "view" | "dictionary" | "func" | "user" | "role" | "policy" | "grant";
+export type SqlTag = "database" | "table" | "view" | "dictionary" | "func" | "user" | "role" | "policy" | "quota" | "settingsProfile" | "grant";
 
 /**
  * The ClickHouse tags, by the modules they are imported from. The package
@@ -22,7 +22,7 @@ export type SqlTag = "database" | "table" | "view" | "dictionary" | "func" | "us
 export const CLICKHOUSE_TEMPLATE_SOURCE: TemplateSource<SqlTag> = {
   dialect: "clickhouse",
   modules: ["@intentius/chant-lexicon-sql", "@intentius/chant-lexicon-sql/clickhouse"],
-  tags: ["database", "table", "view", "dictionary", "func", "user", "role", "policy", "grant"],
+  tags: ["database", "table", "view", "dictionary", "func", "user", "role", "policy", "quota", "settingsProfile", "grant"],
 };
 
 export type FoundTemplate = SqlFoundTemplate<SqlTag>;

package/src/lsp/postgres-template.ts

@@ -138,6 +138,20 @@ export function postgresDeclarations(content: string, fileName = "file.ts"): Pos
           sqlName = text(node.name.span);
           kind = "enum type";
           break;
+        case "composite":
+        case "range":
+          sqlName = text(node.name.span);
+          kind = `${node.statement} type`;
+          break;
+        case "aggregate":
+        case "collation":
+          sqlName = text(node.name.span);
+          kind = node.statement;
+          break;
+        case "eventTrigger":
+          sqlName = text(node.name.span);
+          kind = "event trigger";
+          break;
         case "index":
           sqlName = node.name ? text(node.name.span) : undefined;
           break;

package/src/mcp/index.ts

@@ -10,7 +10,7 @@ import type { McpResourceContribution, McpToolContribution } from "@intentius/ch
 import { createCatalogResource, createDiffTool } from "@intentius/chant/lexicon-plugin-helpers";
 import { sqlSerializer } from "../serializer";
 import { catalogIndex } from "../lsp/catalog";
-import { database, dictionary, func, grant, policy, role, table, user, view } from "../clickhouse/entities";
+import { database, dictionary, func, grant, policy, quota, role, settingsProfile, table, user, view } from "../clickhouse/entities";
 import { SqlSyntaxError } from "../clickhouse/tokens";
 import { existsSync, readFileSync } from "fs";
 import { diffSchemas } from "../clickhouse/plan/diff";
@@ -122,12 +122,12 @@ const searchTool: McpToolContribution = {
 const parseTool: McpToolContribution = {
   name: "parse-ddl",
   description:
-    "Parse one CREATE statement the way its tag does (dialect clickhouse, the default: table, view, database, dictionary, func, user, role, policy, grant; dialect postgres: schema, table, index, view, sequence, type, domain, extension), and return the entity it builds (columns, engine, keys, settings, and for a view its lineage). A statement that does not parse comes back as the error with its line and column, the same one SQLCH001 (ClickHouse) or SQLPG001 (Postgres) reports. The statement is plain DDL: there are no interpolations.",
+    "Parse one CREATE statement the way its tag does (dialect clickhouse, the default: table, view, database, dictionary, func, user, role, policy, quota, settingsProfile, grant; dialect postgres: schema, table, index, view, sequence, type, domain, extension), and return the entity it builds (columns, engine, keys, settings, and for a view its lineage). A statement that does not parse comes back as the error with its line and column, the same one SQLCH001 (ClickHouse) or SQLPG001 (Postgres) reports. The statement is plain DDL: there are no interpolations.",
   inputSchema: {
     type: "object",
     properties: {
       dialect: dialectProp,
-      tag: { type: "string", enum: [...new Set(["table", "view", "database", "dictionary", "func", "user", "role", "policy", "grant", ...POSTGRES_TAGS])], description: "The tag the statement belongs in (ClickHouse: table, view, database, dictionary, func, user, role, policy, grant; Postgres: " + POSTGRES_TAGS.join(", ") + ")" },
+      tag: { type: "string", enum: [...new Set(["table", "view", "database", "dictionary", "func", "user", "role", "policy", "quota", "settingsProfile", "grant", ...POSTGRES_TAGS])], description: "The tag the statement belongs in (ClickHouse: table, view, database, dictionary, func, user, role, policy, quota, settingsProfile, grant; Postgres: " + POSTGRES_TAGS.join(", ") + ")" },
       ddl: { type: "string", description: "The CREATE statement" },
     },
     required: ["tag", "ddl"],
@@ -136,8 +136,8 @@ const parseTool: McpToolContribution = {
     const ddl = String(params.ddl ?? "");
     const tag = String(params.tag);
     if (asDialect(params.dialect) === "postgres") return postgresParse(tag, ddl, position);
-    const build = tag === "table" ? table : tag === "view" ? view : tag === "database" ? database : tag === "dictionary" ? dictionary : tag === "func" ? func : tag === "user" ? user : tag === "role" ? role : tag === "policy" ? policy : tag === "grant" ? grant : undefined;
-    if (!build) throw new Error("tag must be table, view, database, dictionary, func, user, role, policy or grant");
+    const build = tag === "table" ? table : tag === "view" ? view : tag === "database" ? database : tag === "dictionary" ? dictionary : tag === "func" ? func : tag === "user" ? user : tag === "role" ? role : tag === "policy" ? policy : tag === "quota" ? quota : tag === "settingsProfile" ? settingsProfile : tag === "grant" ? grant : undefined;
+    if (!build) throw new Error("tag must be table, view, database, dictionary, func, user, role, policy, quota, settingsProfile or grant");
     const strings = Object.assign([ddl], { raw: [ddl] }) as unknown as TemplateStringsArray;
     try {
       const entity = build(strings);