@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/files/clickhouse.js

@@ -0,0 +1,138 @@
+/**
+ * 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`, `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.
+ *
+ * With `schema` (a database), an object's unqualified name is qualified with
+ * it, and so is the table a row policy or a grant is on; a function, a user
+ * and a role belong to no database and keep their names.
+ */
+import { isTrivia, tokenizeText } from "../clickhouse/tokens.js";
+import { parseCreate } from "../clickhouse/parser.js";
+import { CLICKHOUSE_ENTITY_TYPES, database, dictionary, func, grant, policy, quota, role, settingsProfile, table, user, view } from "../clickhouse/entities.js";
+import { isAccessStatement, parseAccess } from "../clickhouse/access.js";
+import { CLICKHOUSE_TAG_OF } from "../clickhouse/import/generator.js";
+import { describeStatement } from "../clickhouse/import/ir.js";
+import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, undeclarableStatement } from "./common.js";
+import { templateSafe, templateStrings } from "./postgres.js";
+const TAGS = { 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) {
+    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, span, schema) {
+    if (!span)
+        return undefined;
+    const name = tokens.slice(span.from, span.to).filter((t) => !isTrivia(t));
+    const [only] = name;
+    if (!only || name.length !== 1 || (only.kind !== "ident" && only.kind !== "qident"))
+        return undefined;
+    const at = tokens.indexOf(only);
+    return tokensText(tokens.slice(0, at)) + `${quoteBare(schema)}.` + tokensText(tokens.slice(at));
+}
+/** An access statement as the object its tag declares (#3711), or the tag's refusal. */
+function readAccess(sql, options) {
+    let tokens = tokenizeText(sql, 0);
+    let node;
+    try {
+        node = parseAccess(tokens);
+    }
+    catch (e) {
+        // What the tag refuses (a password) is refused in the tag's words.
+        const tag = accessTag(sql.replace(/--[^\n]*\n/g, " ").trim().split(/\s+/, 2).map((w) => w.toUpperCase()));
+        try {
+            tag(templateStrings([templateSafe(sql)]));
+        }
+        catch (refused) {
+            return refused instanceof Error ? refused.message : String(refused);
+        }
+        throw e;
+    }
+    if (options.schema) {
+        const qualified = qualifyBare(tokens, node.statement === "rowPolicy" ? node.table : node.statement === "grant" ? node.target : undefined, options.schema);
+        if (qualified !== undefined) {
+            sql = qualified;
+            tokens = tokenizeText(sql, 0);
+            node = parseAccess(tokens);
+        }
+    }
+    const tag = { user, role, rowPolicy: policy, quota, settingsProfile, grant }[node.statement];
+    let props;
+    try {
+        props = tag(templateStrings([templateSafe(sql)])).props;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+    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 };
+}
+/** The tag that declares an entity type. */
+export function clickhouseTag(type) {
+    const name = CLICKHOUSE_TAG_OF[type];
+    return name ? TAGS[name] : undefined;
+}
+/** The objects a file of ClickHouse DDL declares. Problems are collected, not thrown, so a file is reported whole. */
+export function readClickHouse(ddl, options, problems) {
+    const objects = [];
+    for (const stmt of splitTokens(tokenizeText(ddl, 0), isTrivia)) {
+        let sql = tokensText(stmt);
+        const line = lineAt(ddl, stmt[0].start);
+        const undeclarable = undeclarableStatement("clickhouse", sql);
+        if (undeclarable) {
+            (options.undeclarable ?? problems).push(undeclarable);
+            continue;
+        }
+        if (isAccessStatement(sql)) {
+            try {
+                const read = readAccess(sql, options);
+                if (typeof read === "string")
+                    problems.push(`${read}: ${firstLine(sql)}`);
+                else
+                    objects.push({ ...read, line });
+            }
+            catch (e) {
+                problems.push(`does not parse (${e instanceof Error ? e.message : String(e)}): ${firstLine(sql)}`);
+            }
+            continue;
+        }
+        if (!/^CREATE\b/i.test(sql)) {
+            problems.push(`not a CREATE statement: ${firstLine(sql)}`);
+            continue;
+        }
+        try {
+            const tokens = tokenizeText(sql, 0);
+            const node = parseCreate(tokens);
+            const name = tokens.slice(node.name.from, node.name.to).filter((t) => !isTrivia(t));
+            const [only] = name;
+            if (options.schema && node.statement !== "database" && node.statement !== "function" && only && name.length === 1) {
+                const at = tokens.indexOf(only);
+                sql = tokensText(tokens.slice(0, at)) + `${quoteBare(options.schema)}.` + tokensText(tokens.slice(at));
+            }
+            const unparsed = fileUnparsed(node.unknown, tokens, sql, line);
+            objects.push({ ...describeStatement(sql), line, ...(unparsed ? { unparsed } : {}) });
+        }
+        catch (e) {
+            problems.push(`does not parse (${e instanceof Error ? e.message : String(e)}): ${firstLine(sql)}`);
+        }
+    }
+    return objects;
+}

package/dist/files/common.js

@@ -0,0 +1,58 @@
+/** What reading a file of DDL shares across dialects. */
+import { statementKind } from "../coverage.js";
+/**
+ * A `CREATE` of a kind the coverage table does not mark declared, as the line
+ * that names it with why, or undefined for any other statement.
+ */
+export function undeclarableStatement(dialect, sql) {
+    const row = statementKind(dialect, sql);
+    if (!row || row.status === "declared")
+        return undefined;
+    return `${row.kind}: chant cannot declare it (${row.reason ?? row.status}): ${firstLine(sql)}`;
+}
+/** A file of DDL with statements that declare nothing chant can hold: each problem names its statement. */
+export class SqlFileError extends Error {
+    constructor(origin, problems) {
+        super(`${origin}: ${problems.length === 1 ? "a statement" : `${String(problems.length)} statements`} chant cannot read as declarations:\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+        this.origin = origin;
+        this.problems = problems;
+        this.name = "SqlFileError";
+    }
+}
+/** The statements of a file, each as its tokens (trivia kept inside, trimmed at the ends), split on top-level `;`. */
+export function splitTokens(tokens, isTrivia) {
+    const out = [];
+    let current = [];
+    const flush = () => {
+        let from = 0;
+        let to = current.length;
+        while (from < to && isTrivia(current[from]))
+            from++;
+        while (to > from && isTrivia(current[to - 1]))
+            to--;
+        if (to > from)
+            out.push(current.slice(from, to));
+        current = [];
+    };
+    for (const t of tokens) {
+        if (t.kind === "punct" && t.text === ";")
+            flush();
+        else
+            current.push(t);
+    }
+    flush();
+    return out;
+}
+export const tokensText = (tokens) => tokens.map((t) => t.text).join("");
+/** A statement's unknown clauses with their lines in the file: `line` is the statement's, `sql` its text, `tokens` its tokens. */
+export function fileUnparsed(unknown, tokens, sql, line) {
+    if (!unknown || unknown.length === 0)
+        return undefined;
+    return unknown.map((u) => ({ clause: u.clause, line: line + lineAt(sql, tokens[u.span.from]?.start ?? 0) - 1, ...(u.column !== undefined ? { column: u.column } : {}) }));
+}
+/** The line, from 1, that offset `at` of `text` is on. */
+export const lineAt = (text, at) => text.slice(0, at).split("\n").length;
+/** A statement's first line, for a message. */
+export const firstLine = (s) => (s.split("\n")[0] ?? "").slice(0, 100);
+/** A name as SQL text: bare when it is a plain lower-case identifier, else double-quoted. */
+export const quoteBare = (name) => (/^[a-z_][a-z0-9_]*$/.test(name) ? name : `"${name.replace(/"/g, '""')}"`);

package/dist/files/postgres.js

@@ -0,0 +1,389 @@
+/**
+ * A file of Postgres DDL as the objects it declares: each `CREATE` (and each
+ * `GRANT`, `REVOKE` and `ALTER DEFAULT PRIVILEGES`) is one object, and the
+ * statements that only finish one are folded into it:
+ *
+ * - `COMMENT ON` joins the object it comments on, wherever in the file it is;
+ * - `ALTER TABLE ... ENABLE | DISABLE | FORCE ROW LEVEL SECURITY` joins its table;
+ * - `ALTER TABLE <t> ADD [CONSTRAINT <c>] FOREIGN KEY | UNIQUE | PRIMARY KEY |
+ *   CHECK | EXCLUDE ...`, the form `pg_dump` and ORMs print constraints in,
+ *   becomes a table constraint in `<t>`'s `CREATE TABLE`.
+ *
+ * `BEGIN` and `COMMIT` are skipped. Any other statement, and any statement
+ * the parser or its tag refuses, is a problem naming it: a statement left
+ * out would be a schema change nobody declared.
+ *
+ * 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, composite, range or domain type the file creates.
+ */
+import { isTrivia, tokenizeText } from "../postgres/tokens.js";
+import { identValue, parseStatements } from "../postgres/parser.js";
+import * as tags from "../postgres/entities.js";
+import { POSTGRES_ENTITY_TYPES } from "../postgres/entity-types.js";
+import { POSTGRES_TAG_OF } from "../postgres/import/generator.js";
+import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, undeclarableStatement } from "./common.js";
+/** The tag that declares an entity type. */
+export function postgresTag(type) {
+    const name = POSTGRES_TAG_OF[type];
+    return name ? (tags[name] ?? undefined) : undefined;
+}
+/** A tagged-template call's strings from template-literal text: `raw` as written, as the tag reads it. */
+export function templateStrings(parts) {
+    return Object.assign([...parts], { raw: [...parts] });
+}
+const isName = (t) => t !== undefined && (t.kind === "ident" || t.kind === "qident");
+const word = (t, ...words) => t !== undefined && t.kind === "ident" && words.includes(t.text.toUpperCase());
+/** Text that sits inside a template literal: a backquote and `${` escaped. */
+/** Text that sits inside a template literal: a backquote and `${` escaped. */
+export const templateSafe = (s) => s.replace(/\\(?=`|\$\{)/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+/** Transaction control, which declares nothing. */
+function isTransactionControl(sig) {
+    const words = sig.map((t) => (t.kind === "ident" ? t.text.toUpperCase() : ""));
+    const [first, ...rest] = words;
+    if (first === "BEGIN" || first === "COMMIT" || first === "END")
+        return rest.every((w) => w === "TRANSACTION" || w === "WORK");
+    return first === "START" && rest.length === 1 && rest[0] === "TRANSACTION";
+}
+/**
+ * The objects a file of Postgres DDL declares, each with its statements
+ * joined as one declaration's DDL. Problems are collected, not thrown, so a
+ * file is reported whole.
+ */
+export function readPostgres(ddl, options, problems) {
+    const parsed = [];
+    const alters = [];
+    for (const stmt of splitTokens(tokenizeText(ddl, 0), isTrivia)) {
+        const sig = stmt.filter((t) => !isTrivia(t));
+        const sql = tokensText(stmt);
+        if (isTransactionControl(sig))
+            continue;
+        if (word(sig[0], "ALTER") && word(sig[1], "TABLE")) {
+            const alter = readAlterAdd(stmt, sig);
+            if (alter) {
+                alters.push({ ...alter, sql });
+                continue;
+            }
+        }
+        if (!word(sig[0], "CREATE", "COMMENT", "GRANT", "REVOKE", "ALTER")) {
+            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) });
+        }
+        catch (e) {
+            const what = word(sig[0], "ALTER") && word(sig[1], "TABLE") ? "an ALTER TABLE other than ADD of a table constraint or ROW LEVEL SECURITY" : `does not parse (${e instanceof Error ? e.message : String(e)})`;
+            problems.push(`${what}: ${firstLine(sql)}`);
+        }
+    }
+    const nameOf = (tokens, n) => n.pieces.length > 0 && n.pieces.every((p) => p !== "") ? n.pieces : tokens.slice(n.span.from, n.span.to).filter((t) => isName(t)).map((t) => identValue(t));
+    const qualify = (pieces) => {
+        const name = pieces[pieces.length - 1] ?? "";
+        const schema = pieces.length >= 2 ? pieces[pieces.length - 2] : options.schema;
+        return schema ? { schema, name } : { name };
+    };
+    const key = (q) => `${q.schema ?? ""}.${q.name}`;
+    // The types the file creates, so a column of one is qualified with the rest.
+    const fileTypes = new Set();
+    for (const { tokens, node } of parsed) {
+        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]);
+        }
+    }
+    const objects = [];
+    /** Objects by namespace and name: `rel` (anything in a schema), `index`, `schema`, `extension`, `role`, and `trigger`/`policy` with their table. */
+    const owners = new Map();
+    const followOns = [];
+    for (const { tokens, node, line } of parsed) {
+        const inserts = new Set();
+        /** Qualifies an unqualified name in the statement, when `schema` is set. */
+        const mark = (n) => {
+            if (!n || !options.schema)
+                return;
+            const names = tokens.slice(n.span.from, n.span.to).filter((t) => !isTrivia(t));
+            const [only] = names;
+            if (only && names.length === 1 && isName(only))
+                inserts.add(tokens.indexOf(only));
+        };
+        switch (node.statement) {
+            case "comment":
+                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));
+                }
+                mark(node.on);
+                followOns.push({ tokens, node, inserts });
+                continue;
+            case "rowSecurity":
+                mark(node.table);
+                followOns.push({ tokens, node, inserts });
+                continue;
+            case "index":
+            case "trigger":
+            case "policy":
+                mark(node.table);
+                break;
+            case "table":
+                for (const c of [...node.columns.flatMap((col) => col.constraints), ...node.constraints])
+                    mark(c.references?.table);
+                if (options.schema) {
+                    for (const col of node.columns) {
+                        if (!col.type)
+                            continue;
+                        const type = tokens.slice(col.type.from, col.type.to).filter((t) => !isTrivia(t));
+                        const first = type[0];
+                        if (first && isName(first) && fileTypes.has(identValue(first)) && !(type[1]?.kind === "punct" && type[1].text === "."))
+                            inserts.add(tokens.indexOf(first));
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        if (node.statement === "schema" && !node.name) {
+            problems.push(`a CREATE SCHEMA with no name: ${firstLine(tokensText(tokens))}`);
+            continue;
+        }
+        if (node.statement === "index" && !node.name) {
+            problems.push(`an index with no name (its declaration needs one): ${firstLine(tokensText(tokens))}`);
+            continue;
+        }
+        const ownName = !["schema", "extension", "index", "trigger", "policy", "role", "grant", "cast", "eventTrigger"].includes(node.statement);
+        if (ownName && "name" in node)
+            mark(node.name);
+        const object = { node, statements: [rewrite(tokens, inserts, options.schema)], constraints: [], line, unparsed: fileUnparsed("unknown" in node ? node.unknown : undefined, tokens, tokensText(tokens), line) };
+        objects.push(object);
+        const k = ownerKey(node, tokens, nameOf, qualify);
+        if (k)
+            owners.set(k, object);
+    }
+    for (const f of followOns) {
+        const k = followOnOwner(f.node, f.tokens, nameOf, qualify);
+        const owner = k ? owners.get(k) : undefined;
+        if (!owner) {
+            const what = f.node.statement === "comment" ? `COMMENT ON ${f.node.objectType}` : "ALTER TABLE ... ROW LEVEL SECURITY";
+            problems.push(`${what} for an object the file does not create: ${firstLine(tokensText(f.tokens))}`);
+            continue;
+        }
+        owner.statements.push(rewrite(f.tokens, f.inserts, options.schema));
+    }
+    for (const alter of alters) {
+        const table = owners.get(`rel ${key(qualify(alter.table))}`);
+        if (!table || table.node.statement !== "table") {
+            problems.push(`ALTER TABLE of a table the file does not create: ${firstLine(alter.sql)}`);
+            continue;
+        }
+        table.constraints.push(qualifyConstraint(alter.constraint, options.schema));
+    }
+    const out = [];
+    for (const o of objects) {
+        const [create = [], ...rest] = o.statements;
+        const ddlText = [o.constraints.length > 0 ? addConstraints(create, o.constraints) : tokensText(create), ...rest.map((c) => tokensText(c))].join(";\n");
+        const identity = identify(ddlText);
+        if (typeof identity === "string") {
+            problems.push(`${identity}: ${firstLine(ddlText)}`);
+            continue;
+        }
+        out.push({ ...identity, ddl: ddlText, line: o.line, ...(o.unparsed ? { unparsed: o.unparsed } : {}) });
+    }
+    return out;
+}
+/** An object's entity type, schema and name, read by declaring it with its tag; a string is the tag's refusal. */
+function identify(ddl) {
+    let tokens;
+    let node;
+    try {
+        tokens = tokenizeText(ddl, 0);
+        [node] = parseStatements(tokens);
+    }
+    catch (e) {
+        return `does not parse (${e instanceof Error ? e.message : String(e)})`;
+    }
+    const type = node ? entityTypeOf(node) : undefined;
+    const tag = type ? postgresTag(type) : undefined;
+    if (!type || !tag)
+        return "not a statement that declares an object";
+    try {
+        const entity = tag(templateStrings([templateSafe(ddl)]));
+        const p = entity.props;
+        return { type: entity.entityType, ...(p.schema ? { schema: p.schema } : {}), name: p.name };
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
+    }
+}
+/** The entity type a statement declares. */
+function entityTypeOf(node) {
+    switch (node.statement) {
+        case "view":
+            return node.materialized ? POSTGRES_ENTITY_TYPES.materializedView : POSTGRES_ENTITY_TYPES.view;
+        case "grant":
+            return node.defaults ? POSTGRES_ENTITY_TYPES.defaultPrivileges : POSTGRES_ENTITY_TYPES.grant;
+        case "comment":
+        case "rowSecurity":
+            return undefined;
+        default:
+            return POSTGRES_ENTITY_TYPES[node.statement];
+    }
+}
+const qkey = (q) => `${q.schema ?? ""}.${q.name}`;
+/** The key a created object is found under by the statements folded into it. */
+function ownerKey(node, tokens, nameOf, qualify) {
+    switch (node.statement) {
+        case "schema":
+            return node.name ? `schema ${nameOf(tokens, node.name).at(-1) ?? ""}` : undefined;
+        case "extension":
+            return `extension ${nameOf(tokens, node.name).at(-1) ?? ""}`;
+        case "role":
+            return `role ${nameOf(tokens, node.name).at(-1) ?? ""}`;
+        case "index": {
+            // An index is in its table's schema.
+            const table = nameOf(tokens, node.table);
+            return node.name ? `index ${qkey(qualify([...table.slice(0, -1), nameOf(tokens, node.name).at(-1) ?? ""]))}` : undefined;
+        }
+        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":
+            return undefined;
+        default:
+            return `rel ${qkey(qualify(nameOf(tokens, node.name)))}`;
+    }
+}
+/** The key of the object a COMMENT ON or ALTER TABLE ... ROW LEVEL SECURITY finishes. */
+function followOnOwner(node, tokens, nameOf, qualify) {
+    if (node.statement === "rowSecurity")
+        return `rel ${qkey(qualify(nameOf(tokens, node.table)))}`;
+    if (node.statement !== "comment")
+        return undefined;
+    const target = nameOf(tokens, node.target);
+    switch (node.objectType) {
+        case "SCHEMA":
+            return `schema ${target.at(-1) ?? ""}`;
+        case "EXTENSION":
+            return `extension ${target.at(-1) ?? ""}`;
+        case "ROLE":
+            return `role ${target.at(-1) ?? ""}`;
+        case "INDEX":
+            return `index ${qkey(qualify(target))}`;
+        case "COLUMN":
+            return `rel ${qkey(qualify(target.slice(0, -1)))}`;
+        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;
+        default:
+            return `rel ${qkey(qualify(target))}`;
+    }
+}
+/** A cast's two types as one key, spacing and case aside. */
+function castKey(tokens, source, target) {
+    const text = (sp) => 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, inserts, schema) {
+    if (!schema || inserts.size === 0)
+        return [...tokens];
+    const out = [];
+    tokens.forEach((t, i) => {
+        if (inserts.has(i))
+            out.push({ kind: "ident", text: `${quoteBare(schema)}.`, part: 0, start: 0, end: 0 });
+        out.push(t);
+    });
+    return out;
+}
+/** `ALTER TABLE [IF EXISTS] [ONLY] <name> ADD <table constraint>`: the table's name pieces and the constraint's text. */
+function readAlterAdd(stmt, sig) {
+    let i = 2;
+    if (word(sig[i], "IF") && word(sig[i + 1], "EXISTS"))
+        i += 2;
+    if (word(sig[i], "ONLY"))
+        i++;
+    const table = [];
+    for (let t = sig[i]; t && isName(t); t = sig[i]) {
+        table.push(identValue(t));
+        i++;
+        const dot = sig[i];
+        if (dot?.kind === "punct" && dot.text === ".")
+            i++;
+        else
+            break;
+    }
+    if (table.length === 0 || !word(sig[i], "ADD"))
+        return undefined;
+    i++;
+    if (!word(sig[i], "CONSTRAINT", "FOREIGN", "UNIQUE", "PRIMARY", "CHECK", "EXCLUDE"))
+        return undefined;
+    // One constraint: a comma at depth 0 starts another ALTER action, which is not read.
+    let depth = 0;
+    for (const t of sig.slice(i)) {
+        if (t.kind === "punct" && t.text === "(")
+            depth++;
+        else if (t.kind === "punct" && t.text === ")")
+            depth--;
+        else if (t.kind === "punct" && t.text === "," && depth === 0)
+            return undefined;
+    }
+    const start = sig[i];
+    return start ? { table, constraint: tokensText(stmt.slice(stmt.indexOf(start))) } : undefined;
+}
+/** Qualifies the table a folded FOREIGN KEY references, when it is unqualified. */
+function qualifyConstraint(constraint, schema) {
+    if (!schema)
+        return constraint;
+    const tokens = tokenizeText(constraint, 0);
+    const sig = tokens.map((t, i) => ({ t, i })).filter((x) => !isTrivia(x.t));
+    const inserts = new Set();
+    sig.forEach((x, k) => {
+        const target = sig[k + 1];
+        const dot = sig[k + 2]?.t;
+        if (word(x.t, "REFERENCES") && target && isName(target.t) && !(dot?.kind === "punct" && dot.text === "."))
+            inserts.add(target.i);
+    });
+    return tokensText(rewrite(tokens, inserts, schema));
+}
+/** A CREATE TABLE with table constraints added at the end of its column list (the `)` matching the first `(`). */
+function addConstraints(create, constraints) {
+    let depth = 0;
+    const close = create.findIndex((t) => {
+        if (t.kind !== "punct")
+            return false;
+        if (t.text === "(")
+            depth++;
+        else if (t.text === ")")
+            return --depth === 0;
+        return false;
+    });
+    if (close < 0)
+        return tokensText(create);
+    const before = tokensText(create.slice(0, close)).replace(/\s+$/, "");
+    const indent = /\n([ \t]+)\S[^\n]*$/.exec(before)?.[1] ?? "  ";
+    return `${before}${constraints.map((c) => `,\n${indent}${c}`).join("")}\n${tokensText(create.slice(close))}`;
+}

package/dist/generated/clickhouse-types.js

@@ -0,0 +1,5 @@
+// Generated by `npm run generate` from the ClickHouse catalog at 26.8.15.10
+// (src/spec/clickhouse-catalog.snapshot.json) and the overlays in src/clickhouse/overlays/. Do not edit.
+// The type surface: unions of every named thing in the catalog, and the two settings interfaces.
+/** The ClickHouse release these types were read from. */
+export const CLICKHOUSE_VERSION = "26.8.15.10";