@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/lint/post-synth/sqlch103.js

@@ -0,0 +1,45 @@
+import { baseEngineName, checkOf, columnByName, engineArguments, isNullableType, tablesOf, typeFamily } from "./clickhouse-helpers.js";
+const VERSION_TYPES = new Set(["UInt8", "UInt16", "UInt32", "UInt64", "UInt128", "UInt256", "Date", "DateTime", "DateTime64"]);
+/** engine -> the argument positions that name a column, and the types the engine accepts there. */
+const SPECIAL = {
+    ReplacingMergeTree: [
+        { role: "version", index: 0, accepts: (f) => VERSION_TYPES.has(f), wants: "UInt*, Date, DateTime or DateTime64" },
+        { role: "is_deleted", index: 1, accepts: (f) => f === "UInt8", wants: "UInt8" },
+    ],
+    CollapsingMergeTree: [{ role: "sign", index: 0, accepts: (f) => f === "Int8", wants: "Int8" }],
+    VersionedCollapsingMergeTree: [
+        { role: "sign", index: 0, accepts: (f) => f === "Int8", wants: "Int8" },
+        { role: "version", index: 1, accepts: (f) => VERSION_TYPES.has(f), wants: "UInt*, Date, DateTime or DateTime64" },
+    ],
+};
+/**
+ * SQLCH103: the version, sign or is_deleted column of a Replacing, Collapsing
+ * or VersionedCollapsing table has a type the engine does not accept.
+ *
+ * Docs: https://clickhouse.com/docs/engines/table-engines/mergetree-family/replacingmergetree
+ * (version: UInt*, Date, DateTime or DateTime64; is_deleted: UInt8) and
+ * .../collapsingmergetree, .../versionedcollapsingmergetree (sign: Int8).
+ */
+export const sqlch103 = checkOf({ id: "SQLCH103", description: "An engine's version, sign or is_deleted column has an unsupported type" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (!t.engine)
+            continue;
+        const roles = SPECIAL[baseEngineName(t.engine)];
+        if (!roles)
+            continue;
+        const args = engineArguments(t.engine);
+        for (const r of roles) {
+            const arg = args[r.index];
+            const col = arg ? columnByName(t, arg.replace(/^`|`$/g, "")) : undefined;
+            if (!col?.type)
+                continue;
+            if (!isNullableType(col.type) && r.accepts(typeFamily(col.type)))
+                continue;
+            report({
+                severity: "error",
+                message: `${t.export} (${t.name}): ${r.role} column ${col.name} is ${col.type}; ${t.engine.name} takes ${r.wants}`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch104.js

@@ -0,0 +1,41 @@
+import { baseEngineName, checkOf, engineArguments, splitTop, tablesOf } from "./clickhouse-helpers.js";
+/** The engine arguments that name columns, by base engine. */
+function columnArguments(engine, args) {
+    switch (engine) {
+        case "ReplacingMergeTree":
+            return args.slice(0, 2);
+        case "CollapsingMergeTree":
+            return args.slice(0, 1);
+        case "VersionedCollapsingMergeTree":
+            return args.slice(0, 2);
+        case "SummingMergeTree":
+        case "CoalescingMergeTree":
+            return args.flatMap((a) => splitTop(a.trim().replace(/^\(([\s\S]*)\)$/, "$1")));
+        default:
+            return [];
+    }
+}
+/**
+ * SQLCH104: an engine argument names a column the table does not declare.
+ *
+ * Docs: the engine pages under
+ * https://clickhouse.com/docs/engines/table-engines/mergetree-family/ (the
+ * sign, version, is_deleted and summed columns are columns of the table).
+ */
+export const sqlch104 = checkOf({ id: "SQLCH104", description: "A MergeTree engine argument names a column the table does not declare" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (!t.engine || t.columns.length === 0)
+            continue;
+        const declared = new Set(t.columns.map((c) => c.name));
+        for (const arg of columnArguments(baseEngineName(t.engine), engineArguments(t.engine))) {
+            const name = arg.trim().replace(/^`(.*)`$/, "$1");
+            if (!/^[A-Za-z_]\w*$/.test(name) || declared.has(name))
+                continue;
+            report({
+                severity: "error",
+                message: `${t.export} (${t.name}): ${t.engine.name} names column ${name}, which the table does not declare`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch105.js

@@ -0,0 +1,36 @@
+import { bareName, checkOf, keyElements, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH105: ORDER BY, PRIMARY KEY, PARTITION BY or SAMPLE BY lists a bare
+ * column name the table does not declare.
+ *
+ * Doc: https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree
+ * (the keys are expressions over the table's columns). Only a bare name is
+ * judged; an expression is left to the server.
+ */
+export const sqlch105 = checkOf({ id: "SQLCH105", description: "A table key clause names a column the table does not declare" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (t.columns.length === 0)
+            continue;
+        const declared = new Set(t.columns.map((c) => c.name));
+        const clauses = [
+            ["ORDER BY", t.orderBy],
+            ["PRIMARY KEY", t.primaryKey],
+            ["PARTITION BY", t.partitionBy],
+            ["SAMPLE BY", t.sampleBy],
+        ];
+        for (const [clause, expr] of clauses) {
+            if (!expr)
+                continue;
+            for (const element of keyElements(expr)) {
+                const name = bareName(element);
+                if (name === undefined || declared.has(name))
+                    continue;
+                report({
+                    severity: "error",
+                    message: `${t.export} (${t.name}): ${clause} names column ${name}, which the table does not declare`,
+                    entity: t.export,
+                });
+            }
+        }
+    }
+});

package/dist/lint/post-synth/sqlch106.js

@@ -0,0 +1,27 @@
+import { checkOf, mentionedNames, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH106: a data skipping index expression mentions a column the table does
+ * not declare.
+ *
+ * Doc: https://clickhouse.com/docs/optimize/skipping-indexes (an index is
+ * defined over an expression of the table's columns). Projections are not
+ * checked: their SELECT is a full query, and reading its column names without a
+ * SQL parser would guess.
+ */
+export const sqlch106 = checkOf({ id: "SQLCH106", description: "A skip index expression names a column the table does not declare" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (t.columns.length === 0)
+            continue;
+        const declared = new Set(t.columns.map((c) => c.name));
+        for (const index of t.indexes ?? []) {
+            const missing = [...new Set(mentionedNames(index.expr))].filter((n) => !declared.has(n));
+            if (missing.length === 0)
+                continue;
+            report({
+                severity: "error",
+                message: `${t.export} (${t.name}): index ${index.name} (${index.expr}) names ${missing.join(", ")}, which the table does not declare`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch107.js

@@ -0,0 +1,39 @@
+import { bareName, checkOf, splitTop, tablesOf, typeFamily } from "./clickhouse-helpers.js";
+const DATE_TYPES = new Set(["Date", "Date32", "DateTime", "DateTime64"]);
+const TTL_ACTION = /\s+(DELETE|TO\s+DISK|TO\s+VOLUME|RECOMPRESS|GROUP\s+BY|WHERE)\b[\s\S]*$/i;
+/**
+ * SQLCH107: a TTL expression is a bare column, or a column plus an INTERVAL,
+ * and that column is not a Date or DateTime.
+ *
+ * Doc: https://clickhouse.com/docs/guides/developer/ttl ("The TTL expression
+ * must evaluate to Date or DateTime"). Only the two plain forms are judged;
+ * a function call is left to the server.
+ */
+export const sqlch107 = checkOf({ id: "SQLCH107", description: "A TTL expression is built on a column that is not a Date or DateTime" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        const ttls = [];
+        if (t.ttl)
+            for (const clause of splitTop(t.ttl))
+                ttls.push({ where: "table TTL", expr: clause.replace(TTL_ACTION, "") });
+        for (const c of t.columns)
+            if (c.ttl)
+                ttls.push({ where: `column ${c.name} TTL`, expr: c.ttl.replace(TTL_ACTION, "") });
+        for (const { where, expr } of ttls) {
+            const plain = /^\s*(`[^`]+`|[A-Za-z_]\w*)\s*(?:[+-]\s*INTERVAL\b[\s\S]*)?$/i.exec(expr);
+            if (!plain)
+                continue;
+            const name = bareName(plain[1]);
+            const col = name === undefined ? undefined : t.columns.find((c) => c.name === name);
+            if (!col?.type)
+                continue;
+            const family = typeFamily(col.type);
+            if (DATE_TYPES.has(family))
+                continue;
+            report({
+                severity: "error",
+                message: `${t.export} (${t.name}): ${where} is built on ${col.name}, which is ${col.type}; a TTL expression must be a Date or DateTime`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch108.js

@@ -0,0 +1,28 @@
+import { checkOf, isTable } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH108: CREATE OR REPLACE TABLE in a database whose engine is not Atomic
+ * (or Replicated, which is Atomic underneath).
+ *
+ * Doc: https://clickhouse.com/docs/sql-reference/statements/create/table
+ * ("The REPLACE query is supported only for Atomic and Replicated databases"),
+ * and https://clickhouse.com/docs/engines/database-engines/atomic for
+ * EXCHANGE TABLES. Judged against a database the same build declares.
+ */
+export const sqlch108 = checkOf({ id: "SQLCH108", description: "CREATE OR REPLACE TABLE in a database that is not Atomic" }, (ctx, report) => {
+    const objects = clickhouseObjects(ctx);
+    const databases = new Map(objects.filter((o) => o.type === "ClickHouse::Database").map((d) => [d.name, d]));
+    for (const t of objects.filter(isTable)) {
+        if (!t.orReplace || !t.database)
+            continue;
+        const db = databases.get(t.database);
+        const engine = db?.engine?.name;
+        if (!db || !engine || engine === "Atomic" || engine === "Replicated")
+            continue;
+        report({
+            severity: "error",
+            message: `${t.export} (${t.name}) is CREATE OR REPLACE in database ${t.database}, whose engine is ${engine}; REPLACE needs Atomic or Replicated`,
+            entity: t.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch109.js

@@ -0,0 +1,21 @@
+import { checkOf, isMaterializedView } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH109: a materialized view selects `*`.
+ *
+ * Doc: https://clickhouse.com/docs/materialized-view/incremental-materialized-view
+ * (the view's columns come from the SELECT, and a materialized view is a
+ * trigger on inserts). A star ties the target's columns to whatever the source
+ * has today, so adding a source column changes what the view writes.
+ */
+export const sqlch109 = checkOf({ id: "SQLCH109", description: "A materialized view selects *" }, (ctx, report) => {
+    for (const v of clickhouseObjects(ctx).filter(isMaterializedView)) {
+        if (!(v.lineage ?? []).some((e) => e.expr === "*" || /\.\*$/.test(e.expr)))
+            continue;
+        report({
+            severity: "warning",
+            message: `${v.export} (${v.name}) selects *; list the columns so a new source column does not change what the view writes`,
+            entity: v.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch110.js

@@ -0,0 +1,31 @@
+import { checkOf, isMaterializedView, isTable, resolveObject } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH110: a materialized view writes an output column its TO target table
+ * does not declare.
+ *
+ * Doc: https://clickhouse.com/docs/sql-reference/statements/create/view
+ * (a materialized view with TO inserts the SELECT's result into the target;
+ * columns are matched by name, so a column the target lacks is not stored).
+ * Judged only against a target the same build declares, and only when the
+ * SELECT lists its columns.
+ */
+export const sqlch110 = checkOf({ id: "SQLCH110", description: "A materialized view writes a column its TO target does not declare" }, (ctx, report) => {
+    for (const v of clickhouseObjects(ctx).filter(isMaterializedView)) {
+        if (!v.to || (v.lineage ?? []).some((e) => e.expr === "*" || /\.\*$/.test(e.expr)))
+            continue;
+        const target = resolveObject(ctx, v.to);
+        if (!target || !isTable(target) || target.columns.length === 0)
+            continue;
+        const declared = new Set(target.columns.map((c) => c.name));
+        const outputs = v.columns.length > 0 ? v.columns.map((c) => c.name) : v.lineage.map((e) => e.output);
+        const dropped = outputs.filter((n) => !declared.has(n));
+        if (dropped.length === 0)
+            continue;
+        report({
+            severity: "warning",
+            message: `${v.export} (${v.name}) selects ${dropped.join(", ")}, which ${target.name} does not declare; ClickHouse matches by name, so the value is not stored`,
+            entity: v.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch111.js

@@ -0,0 +1,41 @@
+import { checkOf, splitTop, tablesOf } from "./clickhouse-helpers.js";
+const MAX_VALUES = 100;
+/** The literals a CHECK constrains `column` to, for `col IN (...)` and `col = 'a' OR col = 'b'`. */
+function allowedValues(expr) {
+    const inList = /^\(?\s*(`[^`]+`|[A-Za-z_]\w*)\s+IN\s*\(([\s\S]*)\)\s*\)?$/i.exec(expr.trim());
+    if (inList)
+        return { column: inList[1].replace(/`/g, ""), count: splitTop(inList[2]).length };
+    const ors = expr.split(/\s+OR\s+/i);
+    const eq = ors.map((p) => /^\(?\s*(`[^`]+`|[A-Za-z_]\w*)\s*=\s*'(?:[^'\\]|\\.)*'\s*\)?$/.exec(p.trim()));
+    if (ors.length > 1 && eq.every((m) => m && m[1] === eq[0][1]))
+        return { column: eq[0][1].replace(/`/g, ""), count: ors.length };
+    return undefined;
+}
+/**
+ * SQLCH111: a String column a CHECK constrains to a small set of values is not
+ * LowCardinality.
+ *
+ * Doc: https://clickhouse.com/docs/sql-reference/data-types/lowcardinality
+ * (LowCardinality dictionary-encodes a column and speeds up SELECT for fewer
+ * than about 10,000 distinct values) and
+ * https://clickhouse.com/docs/best-practices/select-data-types.
+ */
+export const sqlch111 = checkOf({ id: "SQLCH111", description: "A String column limited to a few values is not LowCardinality" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.constraints ?? []) {
+            if (c.kind !== "CHECK")
+                continue;
+            const found = allowedValues(c.expr);
+            if (!found || found.count > MAX_VALUES)
+                continue;
+            const col = t.columns.find((x) => x.name === found.column);
+            if (!col?.type || !/^String$/i.test(col.type.trim()))
+                continue;
+            report({
+                severity: "warning",
+                message: `${t.export} (${t.name}): column ${col.name} is String but constraint ${c.name} limits it to ${found.count} values; use LowCardinality(String)`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch112.js

@@ -0,0 +1,28 @@
+import { checkOf, tablesOf, typeFamily } from "./clickhouse-helpers.js";
+const FINE_FUNCTIONS = /\b(toStartOfSecond|toStartOfMinute|toStartOfFiveMinutes?|toStartOfTenMinutes|toStartOfFifteenMinutes|toStartOfHour|toRelativeSecondNum|toRelativeMinuteNum|toRelativeHourNum|toUnixTimestamp|toYYYYMMDDhhmmss|toStartOfInterval)\s*\(/;
+/**
+ * SQLCH112: a PARTITION BY finer than a day.
+ *
+ * Doc: https://clickhouse.com/docs/best-practices/choosing-a-partitioning-key
+ * and the MergeTree page's note that partitioning is not meant to speed up
+ * queries and that "you should not partition by too granular": every
+ * partition is a separate set of parts, and the server stops inserts when a
+ * table has too many (parts_to_throw_insert). Flags a bare DateTime column and
+ * the sub-day truncation functions.
+ */
+export const sqlch112 = checkOf({ id: "SQLCH112", description: "A PARTITION BY expression is finer than a day" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        const expr = t.partitionBy?.trim();
+        if (!expr)
+            continue;
+        const col = t.columns.find((c) => c.name === expr.replace(/^\(|\)$/g, "").trim());
+        const bareDateTime = col?.type && ["DateTime", "DateTime64"].includes(typeFamily(col.type));
+        if (!bareDateTime && !FINE_FUNCTIONS.test(expr))
+            continue;
+        report({
+            severity: "warning",
+            message: `${t.export} (${t.name}) partitions by ${expr}, which makes a partition per second, minute or hour; partition by month or day`,
+            entity: t.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch113.js

@@ -0,0 +1,19 @@
+import { checkOf, isMergeTree, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH113: a MergeTree table with neither ORDER BY nor PRIMARY KEY.
+ *
+ * Doc: https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree
+ * ("ORDER BY: required unless PRIMARY KEY is specified"; write
+ * `ORDER BY tuple()` to have none). The server refuses the CREATE.
+ */
+export const sqlch113 = checkOf({ id: "SQLCH113", description: "A MergeTree table declares no sort key" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (!isMergeTree(t.engine) || t.orderBy || t.primaryKey)
+            continue;
+        report({
+            severity: "error",
+            message: `${t.export} (${t.name}) uses ${t.engine.name} with no ORDER BY or PRIMARY KEY; add one, or ORDER BY tuple() for none`,
+            entity: t.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch114.js

@@ -0,0 +1,26 @@
+import { CODECS } from "../../generated/clickhouse.js";
+import { checkOf, codecNames, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH114: a column CODEC names a codec the pinned server does not have.
+ *
+ * Doc: https://clickhouse.com/docs/sql-reference/statements/create/table#column-compression-codecs.
+ * The list is the pinned server's own (`system.codecs`).
+ */
+export const sqlch114 = checkOf({ id: "SQLCH114", description: "A column codec is not one the pinned server has" }, (ctx, report) => {
+    const known = new Set(Object.keys(CODECS).map((n) => n.toLowerCase()));
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.columns) {
+            if (!c.codec)
+                continue;
+            for (const name of codecNames(c.codec)) {
+                if (known.has(name.toLowerCase()))
+                    continue;
+                report({
+                    severity: "error",
+                    message: `${t.export} (${t.name}): column ${c.name} uses codec ${name}, which the pinned server does not have`,
+                    entity: t.export,
+                });
+            }
+        }
+    }
+});

package/dist/lint/post-synth/sqlch115.js

@@ -0,0 +1,30 @@
+import { CODECS } from "../../generated/clickhouse.js";
+import { checkOf, codecNames, tablesOf } from "./clickhouse-helpers.js";
+const SENSITIVE = /(^|_)(password|passwd|pwd|secret|api_?key|access_?key|private_?key|token|ssn|social_?security|credit_?card|card_?number|iban)(_|$)/i;
+/**
+ * SQLCH115: a column named like a secret or personal data has no COMMENT, no
+ * TTL and no encryption codec.
+ *
+ * Docs: https://clickhouse.com/docs/sql-reference/statements/create/table
+ * (column COMMENT, column TTL, and the AES_128_GCM_SIV / AES_256_GCM_SIV
+ * encryption codecs). The marker is the author saying the column was
+ * considered: a COMMENT stating what it holds, a TTL that bounds how long it
+ * is kept, or a codec that encrypts it. The table's own TTL counts for the
+ * whole row.
+ */
+export const sqlch115 = checkOf({ id: "SQLCH115", description: "A secret- or PII-named column carries no comment, TTL or encryption" }, (ctx, report) => {
+    const encryption = new Set(Object.entries(CODECS).filter(([, s]) => s.encryption).map(([n]) => n.toLowerCase()));
+    for (const t of tablesOf(ctx)) {
+        for (const c of t.columns) {
+            if (!SENSITIVE.test(c.name) || c.comment || c.ttl || t.ttl)
+                continue;
+            if (c.codec && codecNames(c.codec).some((n) => encryption.has(n.toLowerCase())))
+                continue;
+            report({
+                severity: "warning",
+                message: `${t.export} (${t.name}): column ${c.name} looks like a secret or personal data; add a COMMENT, a TTL or an encryption codec`,
+                entity: t.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch116.js

@@ -0,0 +1,22 @@
+import { checkOf, isAnyView } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH116: a view declared SQL SECURITY DEFINER without a DEFINER.
+ *
+ * Doc: https://clickhouse.com/docs/sql-reference/statements/create/view#sql-security
+ * (the DEFINER clause names the user whose privileges the view's SELECT runs
+ * with). Without it the view's access is decided by whoever happened to run
+ * the CREATE, so the same declaration grants different access per environment.
+ */
+export const sqlch116 = checkOf({ id: "SQLCH116", description: "A view is SQL SECURITY DEFINER with no DEFINER" }, (ctx, report) => {
+    for (const v of clickhouseObjects(ctx).filter(isAnyView)) {
+        const security = v.security ?? "";
+        if (!/SQL\s+SECURITY\s+DEFINER/i.test(security) || /\bDEFINER\s*=/i.test(security))
+            continue;
+        report({
+            severity: "warning",
+            message: `${v.export} (${v.name}) is SQL SECURITY DEFINER with no DEFINER = <user>; name the user whose privileges it runs with`,
+            entity: v.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch117.js

@@ -0,0 +1,26 @@
+import { MERGE_TREE_SETTINGS } from "../../generated/clickhouse.js";
+import { checkOf, isMergeTree } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH117: a MergeTree SETTINGS entry the pinned server marks obsolete.
+ *
+ * Doc: https://clickhouse.com/docs/operations/settings/merge-tree-settings.
+ * `system.merge_tree_settings` flags it with tier Obsolete; the server accepts
+ * it and ignores it, so the table does not behave as the setting suggests.
+ */
+export const sqlch117 = checkOf({ id: "SQLCH117", description: "A MergeTree setting is obsolete at the pinned server" }, (ctx, report) => {
+    const specs = MERGE_TREE_SETTINGS;
+    for (const o of clickhouseObjects(ctx)) {
+        if (!isMergeTree(o.engine) && o.type !== "ClickHouse::MaterializedView")
+            continue;
+        for (const name of Object.keys(o.settings ?? {})) {
+            if (!specs[name]?.obsolete)
+                continue;
+            report({
+                severity: "warning",
+                message: `${o.export} (${o.name}) sets ${name}, which is obsolete and does nothing at ClickHouse 26.8; remove it`,
+                entity: o.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch118.js

@@ -0,0 +1,27 @@
+import { MERGE_TREE_SETTINGS } from "../../generated/clickhouse.js";
+import { checkOf, isMergeTree } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH118: a MergeTree SETTINGS entry the pinned server does not have.
+ *
+ * Doc: https://clickhouse.com/docs/operations/settings/merge-tree-settings.
+ * The list is the pinned server's `system.merge_tree_settings`; an unknown
+ * name (usually a typo, or a setting a later release added) fails the CREATE
+ * with "Unknown setting".
+ */
+export const sqlch118 = checkOf({ id: "SQLCH118", description: "A MergeTree setting is not one the pinned server has" }, (ctx, report) => {
+    const known = MERGE_TREE_SETTINGS;
+    for (const o of clickhouseObjects(ctx)) {
+        if (o.type !== "ClickHouse::Table" || !isMergeTree(o.engine))
+            continue;
+        for (const name of Object.keys(o.settings ?? {})) {
+            if (name in known)
+                continue;
+            report({
+                severity: "error",
+                message: `${o.export} (${o.name}) sets ${name}, which ClickHouse 26.8 does not have as a MergeTree setting`,
+                entity: o.export,
+            });
+        }
+    }
+});

package/dist/lint/post-synth/sqlch119.js

@@ -0,0 +1,32 @@
+import { DATABASE_ENGINES, TABLE_ENGINES } from "../../generated/clickhouse.js";
+import { checkOf } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH119: an engine the pinned catalog describes as deprecated or experimental.
+ *
+ * Docs: https://clickhouse.com/docs/engines/database-engines/ordinary (the
+ * legacy, deprecated default replaced by Atomic) and the engine pages the
+ * snapshot's summaries come from (`This engine is experimental`,
+ * ExperimentalBadge). The words are read from the committed catalog snapshot,
+ * so a pin move changes the verdict.
+ */
+export const sqlch119 = checkOf({ id: "SQLCH119", description: "An object uses a deprecated or experimental engine" }, (ctx, report) => {
+    const tables = TABLE_ENGINES;
+    const databases = DATABASE_ENGINES;
+    for (const o of clickhouseObjects(ctx)) {
+        const name = o.engine?.name;
+        if (!name)
+            continue;
+        const isDatabase = o.type === "ClickHouse::Database";
+        const summary = (isDatabase ? databases : tables)[name]?.summary ?? "";
+        const deprecated = /\bdeprecated\b/i.test(summary);
+        const experimental = isDatabase ? /ExperimentalBadge/.test(summary) : /\b(is|are) (an )?experimental\b/i.test(summary);
+        if (!deprecated && !experimental)
+            continue;
+        report({
+            severity: "warning",
+            message: `${o.export} (${o.name}) uses the ${deprecated ? "deprecated" : "experimental"} engine ${name}`,
+            entity: o.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch120.js

@@ -0,0 +1,20 @@
+import { checkOf, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH120: a MergeTree engine written with the legacy positional arguments.
+ *
+ * Doc: https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree
+ * ("Deprecated Method for Creating a Table": `MergeTree(date-column
+ * [, sampling_expression], (primary, key), index_granularity)`). Current
+ * syntax is a bare `MergeTree` with ORDER BY, PARTITION BY and SETTINGS.
+ */
+export const sqlch120 = checkOf({ id: "SQLCH120", description: "A MergeTree engine uses the deprecated positional arguments" }, (ctx, report) => {
+    for (const t of tablesOf(ctx)) {
+        if (t.engine?.name !== "MergeTree" || (t.engine.args ?? []).length === 0)
+            continue;
+        report({
+            severity: "warning",
+            message: `${t.export} (${t.name}) is MergeTree(${t.engine.args.join(", ")}), the deprecated positional form; use ORDER BY, PARTITION BY and SETTINGS`,
+            entity: t.export,
+        });
+    }
+});

package/dist/lint/post-synth/sqlch121.js

@@ -0,0 +1,11 @@
+import { checkOf } from "./clickhouse-helpers.js";
+import { reportTypeFindings } from "./clickhouse-type-check.js";
+/**
+ * SQLCH121: a column type names a family the pinned server does not have
+ * (`UInt46`, `uint64`, `Nullabel(String)`), at any depth of the type.
+ *
+ * The family list is the pinned server's own (`system.data_type_families`),
+ * aliases included; a name is case-sensitive unless the catalog marks it
+ * case-insensitive.
+ */
+export const sqlch121 = checkOf({ id: "SQLCH121", description: "A column type names a family the pinned server does not have" }, reportTypeFindings("SQLCH121"));

package/dist/lint/post-synth/sqlch122.js

@@ -0,0 +1,11 @@
+import { checkOf } from "./clickhouse-helpers.js";
+import { reportTypeFindings } from "./clickhouse-type-check.js";
+/**
+ * SQLCH122: a column type's parameters do not fit the family: parameters on a
+ * family that takes none, a required one missing (`FixedString`), too many,
+ * or a number outside its range (`Decimal(100, 2)`).
+ *
+ * The parameter grammar is the `TYPE_PARAMETERS` overlay; no system table
+ * holds it.
+ */
+export const sqlch122 = checkOf({ id: "SQLCH122", description: "A column type's parameters do not fit its family" }, reportTypeFindings("SQLCH122"));

package/dist/lint/post-synth/sqlch123.js

@@ -0,0 +1,10 @@
+import { checkOf } from "./clickhouse-helpers.js";
+import { reportTypeFindings } from "./clickhouse-type-check.js";
+/**
+ * SQLCH123: `Nullable` around a type ClickHouse keeps out of it: `Array`,
+ * `Map`, `Nested`, `LowCardinality`, `Variant` or another `Nullable`. The
+ * server refuses the column ("Nested type ... cannot be inside Nullable
+ * type"). `Nullable(Tuple(...))` is left alone: the server takes it when the
+ * profile enables `enable_nullable_tuple_type`.
+ */
+export const sqlch123 = checkOf({ id: "SQLCH123", description: "A Nullable wraps a type ClickHouse does not allow inside Nullable" }, reportTypeFindings("SQLCH123"));

package/dist/lint/post-synth/sqlch124.js

@@ -0,0 +1,21 @@
+import { checkOf } from "./clickhouse-helpers.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH124: a table, view or dictionary declares a column twice. The server
+ * refuses the `CREATE` ("Column ... already exists").
+ */
+export const sqlch124 = checkOf({ id: "SQLCH124", description: "A table declares a column twice" }, (ctx, report) => {
+    for (const o of clickhouseObjects(ctx)) {
+        if (!/^ClickHouse::(Table|View|MaterializedView|Dictionary)$/.test(o.type))
+            continue;
+        const seen = new Set();
+        const reported = new Set();
+        for (const c of (o.columns ?? [])) {
+            if (seen.has(c.name) && !reported.has(c.name)) {
+                reported.add(c.name);
+                report({ severity: "error", message: `${o.export} (${o.name}) declares column ${c.name} twice`, entity: o.export });
+            }
+            seen.add(c.name);
+        }
+    }
+});