@intentius/chant-lexicon-sql 0.124.18 → 0.124.21

package/src/files/postgres.ts

@@ -16,17 +16,17 @@
  * 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";
 import type { ImportedPgObject } from "../postgres/import/ir";
-import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, type FileLine, type ReadOptions } from "./common";
+import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, undeclarableStatement, type FileLine, type ReadOptions } from "./common";
 
 type Tag = (strings: TemplateStringsArray, ...values: unknown[]) => Declarable;
 
@@ -91,6 +91,11 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
       problems.push(`not a statement that declares an object: ${firstLine(sql)}`);
       continue;
     }
+    const undeclarable = undeclarableStatement("postgres", sql);
+    if (undeclarable) {
+      (options.undeclarable ?? problems).push(undeclarable);
+      continue;
+    }
     try {
       const tokens = tokenizeText(sql, 0);
       for (const node of parseStatements(tokens)) parsed.push({ tokens, node, line: lineAt(ddl, stmt[0]!.start) });
@@ -112,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]!);
     }
@@ -133,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));
@@ -172,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);
@@ -272,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":
@@ -300,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;
@@ -308,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/import-parser.ts

@@ -9,7 +9,9 @@
  * anything else is ClickHouse.
  *
  * A statement that declares nothing, or does not parse, is an error naming
- * it (`./sql-files.ts`); none is left out. A clause the parser does not know
+ * it (`./sql-files.ts`); none is left out. So is a `CREATE` of a kind chant
+ * cannot declare (#3911, `./coverage.ts`): `--parser-option
+ * skipUndeclarable` imports the rest and lists those as warnings. A clause the parser does not know
  * (#3872) is kept in the template as written.
  */
 
@@ -52,13 +54,19 @@ export function dialectOption(options: ParserOptions | undefined): SqlDialect |
 }
 
 export class SqlFileParser implements TemplateParser {
-  constructor(private readonly dialect?: SqlDialect) {}
+  constructor(
+    private readonly dialect?: SqlDialect,
+    private readonly options: { skipUndeclarable?: boolean } = {},
+  ) {}
 
   parse(content: string): TemplateIR {
     const dialect = this.dialect ?? guessDialect(content);
     const problems: string[] = [];
-    const ir = dialect === "postgres" ? pgObjectsToIR(readPostgres(content, { origin: "the DDL" }, problems)) : chObjectsToIR(readClickHouse(content, { origin: "the DDL" }, problems));
+    const skipped: string[] = [];
+    const read = { origin: "the DDL", ...(this.options.skipUndeclarable ? { undeclarable: skipped } : {}) };
+    const ir = dialect === "postgres" ? pgObjectsToIR(readPostgres(content, read, problems)) : chObjectsToIR(readClickHouse(content, read, problems));
     if (problems.length > 0) throw new SqlFileError(`the ${dialect === "postgres" ? "Postgres" : "ClickHouse"} DDL`, problems);
-    return ir;
+    if (skipped.length === 0) return ir;
+    return { ...ir, warnings: [...(ir.warnings ?? []), ...skipped.map((s) => `left out (skipUndeclarable): ${s}`)] };
   }
 }

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);

package/src/mcp/postgres.ts

@@ -81,7 +81,7 @@ export function postgresSearch(params: Record<string, unknown>): unknown {
   };
 }
 
-const TAGS = { schema: pg.schema, table: pg.table, index: pg.index, view: pg.view, sequence: pg.sequence, type: pg.type, domain: pg.domain, extension: pg.extension, func: pg.func, procedure: pg.procedure, trigger: pg.trigger, policy: pg.policy, role: pg.role, grant: pg.grant } as const;
+const TAGS = { schema: pg.schema, table: pg.table, index: pg.index, view: pg.view, sequence: pg.sequence, type: pg.type, domain: pg.domain, extension: pg.extension, func: pg.func, procedure: pg.procedure, aggregate: pg.aggregate, trigger: pg.trigger, eventTrigger: pg.eventTrigger, collation: pg.collation, cast: pg.cast, policy: pg.policy, role: pg.role, grant: pg.grant } as const;
 export const POSTGRES_TAGS = Object.keys(TAGS);
 
 /** Parse one statement with the Postgres tag; an error comes back as SQLPG001 with its line and column. */

package/src/plugin.ts

@@ -99,15 +99,21 @@ export const sqlPlugin: LexiconPlugin = {
       },
       { name: "dictionary", isTag: true, description: "A ClickHouse CREATE DICTIONARY, parsed into a dictionary entity with its attributes, key, source and layout" },
       { name: "user", isTag: true, description: "A ClickHouse CREATE USER, parsed into a user entity; its password is the environment's" },
+      { name: "quota", isTag: true, description: "A ClickHouse CREATE QUOTA, parsed into a quota entity with its key, its intervals' limits and whom it applies to" },
+      { name: "settingsProfile", isTag: true, description: "A ClickHouse CREATE SETTINGS PROFILE, parsed into a settings profile entity with its settings, constraints and inherited profiles" },
       { name: "schema", isTag: true, description: "A Postgres CREATE SCHEMA, parsed into a schema entity" },
       { name: "index", isTag: true, description: "A Postgres CREATE INDEX, parsed into an index entity" },
       { name: "sequence", isTag: true, description: "A Postgres CREATE SEQUENCE, parsed into a sequence entity" },
-      { name: "type", isTag: true, description: "A Postgres CREATE TYPE ... AS ENUM, parsed into an enum entity" },
+      { name: "type", isTag: true, description: "A Postgres CREATE TYPE ... AS ENUM, AS (...) or AS RANGE, parsed into an enum, composite or range type entity" },
       { name: "domain", isTag: true, description: "A Postgres CREATE DOMAIN, parsed into a domain entity" },
       { name: "extension", isTag: true, description: "A Postgres CREATE EXTENSION, parsed into an extension entity" },
       { name: "func", isTag: true, description: "A Postgres CREATE FUNCTION, parsed into a function entity with its body kept verbatim, or a ClickHouse CREATE FUNCTION (a named lambda)" },
       { name: "procedure", isTag: true, description: "A Postgres CREATE PROCEDURE, parsed into a procedure entity with its body kept verbatim" },
+      { 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: "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" },
       { name: "role", isTag: true, description: "A Postgres CREATE ROLE without a password or memberships, parsed into a role entity, or a ClickHouse CREATE ROLE" },
       { name: "grant", isTag: true, description: "A Postgres GRANT, REVOKE or ALTER DEFAULT PRIVILEGES, parsed into the privileges it declares, or a ClickHouse GRANT of privileges or roles" },
@@ -159,7 +165,7 @@ 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));
+    return new SqlFileParser(dialectOption(options), { skipUndeclarable: options?.skipUndeclarable === true });
   },
 
   parserOptions() {
@@ -169,6 +175,11 @@ export const sqlPlugin: LexiconPlugin = {
         type: "string" as const,
         description: "the DDL's dialect, clickhouse or postgres; read off its statements when omitted",
       },
+      {
+        name: "skipUndeclarable",
+        type: "boolean" as const,
+        description: "import the rest of the file, and list each CREATE of a kind chant cannot declare (an aggregate, a cast, a quota) as a warning instead of failing",
+      },
     ];
   },
 

package/src/postgres/apply/apply.ts

@@ -151,7 +151,7 @@ export const refName = (o: { kind: CanonicalKind; schema?: string; name: string;
     ? `${o.name}${o.signature ?? ""}`
     : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.schema === undefined
       ? o.name
-      : `${o.schema}.${o.name}${o.kind === "function" || o.kind === "procedure" ? (o.signature ?? "") : ""}`;
+      : `${o.schema}.${o.name}${o.kind === "function" || o.kind === "procedure" || o.kind === "aggregate" ? (o.signature ?? "") : ""}`;
 
 /**
  * The objects a Postgres `chant build` output declares, in creation order,
@@ -564,7 +564,13 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
       "Postgres::MaterializedView": "materializedView",
       "Postgres::Sequence": "sequence",
       "Postgres::Enum": "enum",
+      "Postgres::CompositeType": "composite",
+      "Postgres::RangeType": "range",
       "Postgres::Domain": "domain",
+      "Postgres::Aggregate": "aggregate",
+      "Postgres::Collation": "collation",
+      "Postgres::Cast": "cast",
+      "Postgres::EventTrigger": "eventTrigger",
       "Postgres::Extension": "extension",
       "Postgres::Function": "function",
       "Postgres::Procedure": "procedure",
@@ -577,7 +583,7 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
   )[o.type];
   return {
     kind,
-    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" ? { schema: o.schema } : {}),
+    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" && kind !== "cast" && kind !== "eventTrigger" ? { schema: o.schema } : {}),
     name: o.name,
     ...(o.signature !== undefined ? { signature: o.signature } : {}),
   };

package/src/postgres/apply/statements.ts

@@ -100,12 +100,15 @@ export const pgString = (value: string): string => `'${value.replace(/'/g, "''")
 export const pgQualified = (schema: string | undefined, name: string): string => (schema ? `${quoteIdent(schema)}.${quoteIdent(name)}` : quoteIdent(name));
 
 /**
- * An object's name in a statement. A schema and an extension have no schema;
- * a routine is named with its parameter types (`app.f(integer,text)`), a
- * trigger with its table (`touch ON app.users`).
+ * An object's name in a statement. A schema, an extension and an event
+ * trigger have no schema; a routine or an aggregate is named with its
+ * parameter types (`app.f(integer,text)`), a trigger with its table
+ * (`touch ON app.users`), a cast by its types (`(app.money AS numeric)`).
  */
 export const objectIdent = (o: { kind: CanonicalKind; schema?: string; name: string; signature?: string }): string =>
-  o.kind === "schema" || o.kind === "extension" || o.kind === "role"
+  o.kind === "cast"
+    ? o.name
+    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger"
     ? quoteIdent(o.name)
     : o.kind === "trigger" || o.kind === "policy"
       ? `${quoteIdent(o.name)}${o.signature ?? ""}`
@@ -120,10 +123,16 @@ export const KIND_WORDS: Readonly<Record<CanonicalKind, string>> = {
   materializedView: "MATERIALIZED VIEW",
   sequence: "SEQUENCE",
   enum: "TYPE",
+  composite: "TYPE",
+  range: "TYPE",
   domain: "DOMAIN",
   extension: "EXTENSION",
   function: "FUNCTION",
   procedure: "PROCEDURE",
+  aggregate: "AGGREGATE",
+  collation: "COLLATION",
+  cast: "CAST",
+  eventTrigger: "EVENT TRIGGER",
   trigger: "TRIGGER",
   policy: "POLICY",
   role: "ROLE",
@@ -254,7 +263,12 @@ export function createSteps(
     // A table's row-level security is access, which only a profile that manages access applies.
     if (i > 0 && opts.access === false && firstNode(s)?.statement === "rowSecurity") return;
     let sql = s.text;
-    const replaceable = obj.canonical.kind === "view" || obj.canonical.kind === "function" || obj.canonical.kind === "procedure" || (obj.canonical.kind === "trigger" && obj.canonical.fields.constraint !== true);
+    const replaceable =
+      obj.canonical.kind === "view" ||
+      obj.canonical.kind === "function" ||
+      obj.canonical.kind === "procedure" ||
+      obj.canonical.kind === "aggregate" ||
+      (obj.canonical.kind === "trigger" && obj.canonical.fields.constraint !== true);
     if (i === 0 && opts.orReplace && replaceable && !/^\s*CREATE\s+OR\s+REPLACE\b/i.test(sql)) sql = sql.replace(/\bCREATE\s+/i, "CREATE OR REPLACE ");
     const concurrently = i === 0 && obj.canonical.kind === "index" && obj.props.concurrently === true;
     out.push({ ...step(sql, cls, opts.rule, !concurrently), ...(concurrently ? { buildsIndex: objectIdent(obj.canonical) } : {}) });
@@ -528,7 +542,7 @@ export const isRefused = (c: PgChange): boolean => c.class === "expand";
 export const isDestructive = (c: PgChange): boolean => c.rule === "SQLPG204";
 
 /** Changes that replace the object: drop it and create it again from its declaration. */
-export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243" || c.rule === "SQLPG281";
+export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243" || c.rule === "SQLPG281" || c.rule === "SQLPG300";
 
 /**
  * SET NOT NULL on a table that exists, without reading the table under
@@ -692,6 +706,7 @@ export function alterSteps(
         break;
       case "SQLPG250":
       case "SQLPG280":
+      case "SQLPG302":
         steps.push(...createSteps(obj, opts.marker, { orReplace: true, cls: c.class, rule: c.rule }).slice(0, 1));
         break;
       case "SQLPG291": {
@@ -872,11 +887,19 @@ const DROP_ORDER: Record<CanonicalKind, number> = {
   index: 3,
   table: 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,
   // A routine after what calls it (a view, a trigger, a default), before the types its parameters use.
   function: 6,
   procedure: 6,
   domain: 7,
+  composite: 7.5,
+  range: 7.5,
   enum: 8,
+  // A collation after the types and columns that use it.
+  collation: 8.5,
   extension: 9,
   schema: 10,
   // A role is the cluster's: never dropped by a prune (`../live/catalog.ts` reads only the declared ones).

package/src/postgres/entities.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "vitest";
 import { isDeclarable } from "@intentius/chant/declarable";
 import { getInterpolationFields } from "@intentius/chant/provenance";
-import { domain, extension, index, isColumnRef, literal, schema, sequence, SqlTemplateError, table, type, view } from "./entities";
+import { domain, extension, index, isColumnRef, literal, schema, sequence, SqlTemplateError, table, type, view, type EnumProps } from "./entities";
 
 const app = schema`CREATE SCHEMA app`;
 const orderStatus = type`CREATE TYPE ${app}.order_status AS ENUM ('placed', 'paid')`;
@@ -121,7 +121,7 @@ describe("indexes, views and the rest", () => {
     const e = extension`CREATE EXTENSION IF NOT EXISTS citext WITH SCHEMA ${app} VERSION '1.6'`;
     expect(e.props).toMatchObject({ name: "citext", schema: "app", version: "1.6", ifNotExists: true });
     expect(e.dependsOn).toEqual([app]);
-    expect(orderStatus.props.labels).toEqual(["placed", "paid"]);
+    expect((orderStatus.props as EnumProps).labels).toEqual(["placed", "paid"]);
   });
 });