@intentius/chant-lexicon-sql 0.121.1 → 0.122.0

package/src/lint/audit-catalog.ts

@@ -66,6 +66,14 @@ export const sqlAuditCatalog: Record<string, RuleMeta> = {
     "Use an engine from the pinned server's system.table_engines (or system.database_engines for a database).",
     { category: "correctness" },
   ),
+  SQL101: auditRule(
+    "SQL101",
+    "merge-worthy",
+    "guidance",
+    "Two exports declare the same object",
+    "Keep one declaration of the object and import it where the other was used.",
+    { category: "correctness" },
+  ),
   ...sqlPostSynthAuditEntries,
   ...postgresPostSynthAuditEntries,
 };

package/src/lint/post-synth/audit-entries.ts

@@ -26,4 +26,11 @@ export const sqlPostSynthAuditEntries: Record<string, RuleMeta> = {
   SQLCH118: auditRule("SQLCH118", "merge-worthy", "guidance", "A MergeTree setting is not one the pinned server has", "Fix the setting name, or pick a setting from the pinned server's system.merge_tree_settings.", { category: "correctness" }),
   SQLCH119: auditRule("SQLCH119", "report-only", "guidance", "An object uses a deprecated or experimental engine", "Use the engine that replaced it (Atomic for Ordinary), or accept the experimental engine knowingly.", { category: "best-practice" }),
   SQLCH120: auditRule("SQLCH120", "report-only", "guidance", "A MergeTree engine uses the deprecated positional arguments", "Write a bare MergeTree with ORDER BY, PARTITION BY and SETTINGS.", { category: "best-practice" }),
+  SQLCH121: auditRule("SQLCH121", "merge-worthy", "guidance", "A column type names a family the pinned server does not have", "Use a type family from the pinned server's system.data_type_families, in the case it lists unless it is case-insensitive.", { category: "correctness" }),
+  SQLCH122: auditRule("SQLCH122", "merge-worthy", "guidance", "A column type's parameters do not fit its family", "Give the family the parameters it takes, each within its range.", { category: "correctness" }),
+  SQLCH123: auditRule("SQLCH123", "merge-worthy", "guidance", "A Nullable wraps a type ClickHouse does not allow inside Nullable", "Move Nullable inside (Array(Nullable(T)), LowCardinality(Nullable(T))) or drop it.", { category: "correctness" }),
+  SQLCH124: auditRule("SQLCH124", "merge-worthy", "guidance", "A table declares a column twice", "Remove or rename one of the two columns.", { category: "correctness" }),
+  SQLCH125: auditRule("SQLCH125", "merge-worthy", "guidance", "A codec parameter is outside what the codec takes", "Give the codec a parameter within its range or set, or drop the parameter for the default.", { category: "correctness" }),
+  SQLCH126: auditRule("SQLCH126", "merge-worthy", "guidance", "A GRANT column list names a column the table does not declare", "Fix the column name, or declare the column on the table.", { category: "correctness" }),
+  SQLCH127: auditRule("SQLCH127", "merge-worthy", "guidance", "An expression calls a function the pinned server does not have", "Fix the function name, use one from the pinned server's system.functions, or declare it with func.", { category: "correctness" }),
 };

package/src/lint/post-synth/clickhouse-catalog-checks.test.ts

@@ -0,0 +1,315 @@
+/**
+ * SQLCH121 to SQLCH127 and SQL101 (#3750): column types, codec parameters,
+ * grant columns and function calls against the pinned catalog, and the same
+ * object declared twice. Each flagged case is one the probe found building
+ * with exit 0; each clean case is a correct declaration that must stay clean.
+ */
+import { describe, expect, test } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { sqlSerializer } from "../../serializer";
+import { database, dictionary, func, grant, role, table, view } from "../../clickhouse/entities";
+import { schema, table as pgTable, type as pgType } from "../../postgres/entities";
+import { sqlAuditCatalog } from "../audit-catalog";
+import { postSynthChecks } from "./index";
+import { calledNames, isKnownFunction } from "./sqlch127";
+import { typeFindings } from "./clickhouse-type-check";
+
+type Entities = Record<string, unknown>;
+
+function run(id: string, entities: Entities) {
+  const check = postSynthChecks.find((c: PostSynthCheck) => c.id === id)!;
+  const out = sqlSerializer.serialize(new Map(Object.entries(entities)) as never) as SerializerResult;
+  return check.check(makePostSynthCtx("sql", out.primary));
+}
+
+const flagged = (id: string, entities: Entities, text: RegExp) => {
+  const diags = run(id, entities);
+  expect(diags.length, JSON.stringify(diags)).toBe(1);
+  expect(diags[0]).toMatchObject({ checkId: id, lexicon: "sql", severity: "error" });
+  expect(diags[0]!.message).toMatch(text);
+  return diags[0]!;
+};
+
+const clean = (id: string, entities: Entities) => expect(run(id, entities)).toEqual([]);
+
+const NEW = ["SQL101", "SQLCH121", "SQLCH122", "SQLCH123", "SQLCH124", "SQLCH125", "SQLCH126", "SQLCH127"];
+
+const shop = database`CREATE DATABASE shop ENGINE = Atomic`;
+/** One table with the column list given, in the probe's shape. */
+const events = (columns: string) =>
+  table`CREATE TABLE ${shop}.events (${columns as unknown as never}) ENGINE = MergeTree ORDER BY tuple()`;
+
+describe("registration", () => {
+  test("each new check is registered with an audit entry", () => {
+    const ids = postSynthChecks.map((c) => c.id);
+    for (const id of NEW) {
+      expect(ids, id).toContain(id);
+      expect(sqlAuditCatalog[id], id).toBeDefined();
+    }
+  });
+});
+
+/** Correct column types of every shape ClickHouse accepts. */
+const CORRECT_TYPES = [
+  "UInt64",
+  "BIGINT UNSIGNED",
+  "bigint",
+  "Int32 UNSIGNED",
+  "INT(11)",
+  "UInt64(8)",
+  "VARCHAR(255)",
+  "String",
+  "text",
+  "datetime",
+  "DOUBLE PRECISION",
+  "Float64",
+  "bool",
+  "Bool",
+  "LowCardinality(String)",
+  "LowCardinality(Nullable(String))",
+  "Array(Nullable(String))",
+  "Array(Array(UInt8))",
+  "Nullable(String)",
+  "Map(String, UInt64)",
+  "Map(LowCardinality(String), Array(Nullable(Float64)))",
+  "Tuple(String, UInt8)",
+  "Tuple(a String, b Nullable(UInt8))",
+  "Tuple(date Date, `x y` String)",
+  "Tuple()",
+  "Nullable(Tuple(a String, b UInt8))",
+  "Nested(x UInt8, y String)",
+  "AggregateFunction(uniq, UInt64)",
+  "AggregateFunction(quantiles(0.5, 0.9), Float64)",
+  "AggregateFunction(count)",
+  "AggregateFunction(argMax, String, DateTime)",
+  "SimpleAggregateFunction(sum, UInt64)",
+  "SimpleAggregateFunction(anyLast, Nullable(String))",
+  "DateTime('UTC')",
+  "DateTime64(3, 'UTC')",
+  "DateTime64",
+  "Decimal(18, 4)",
+  "Decimal(76, 2)",
+  "DECIMAL(10, 2)",
+  "Decimal",
+  "Decimal64(4)",
+  "Enum8('a' = 1, 'b(' = 2)",
+  "Enum('a', 'b')",
+  "FixedString(16)",
+  "UUID",
+  "IPv4",
+  "Variant(String, UInt64)",
+  "JSON(max_dynamic_paths = 10, a.b UInt32)",
+  "Dynamic(max_types = 8)",
+  "String COLLATE utf8",
+  "Point",
+];
+
+describe("SQLCH121, SQLCH122, SQLCH123: column types", () => {
+  test.each(CORRECT_TYPES)("%s is clean", (type) => {
+    expect(typeFindings(type, "test")).toEqual([]);
+  });
+
+  test("UInt46 is not a family (probe type-unknown)", () => {
+    flagged("SQLCH121", { shop, events: events("id UInt46, at DateTime") }, /column id UInt46: UInt46 is not a type family ClickHouse \d/);
+  });
+  test("uint64 is case-sensitive (probe type-case)", () => {
+    flagged("SQLCH121", { shop, events: events("id uint64") }, /uint64 is not a type family .* \(it has UInt64, and that name is case-sensitive\)/);
+  });
+  test("Nullabel(String) is not a family (probe wrapper-unknown)", () => {
+    flagged("SQLCH121", { shop, events: events("id UInt64, note Nullabel(String)") }, /column note Nullabel\(String\): Nullabel is not/);
+  });
+  test.each(["Array(UInt46)", "Map(String, UInt46)", "Tuple(a UInt46)", "Nested(a UInt46)", "Nullable(UInt46)", "LowCardinality(UInt46)", "Variant(String, UInt46)", "AggregateFunction(uniq, UInt46)", "SimpleAggregateFunction(sum, UInt46)", "Array(Map(String, Array(UInt46)))"])(
+    "a family is checked at every depth: %s",
+    (type) => {
+      expect(typeFindings(type, "test")).toEqual([{ checkId: "SQLCH121", detail: expect.stringMatching(/^UInt46 is not/) }]);
+    },
+  );
+  test("FixedString with no length (probe type-params-missing)", () => {
+    flagged("SQLCH122", { shop, events: events("id UInt64, code FixedString") }, /FixedString needs its length/);
+  });
+  test("Decimal(100, 2) (probe type-params-bad)", () => {
+    flagged("SQLCH122", { shop, events: events("id UInt64, amount Decimal(100, 2)") }, /Decimal precision 100 is outside 1 to 76/);
+  });
+  test.each([
+    ["UUID(4)", /UUID takes no parameters/],
+    ["UInt64(8, 2)", /UInt64 takes at most 1 parameter/],
+    ["Decimal(10, 2, 1)", /Decimal takes at most 2 parameters/],
+    ["DateTime64(12)", /DateTime64 precision 12 is outside 0 to 9/],
+    ["Map(String)", /Map needs its value/],
+    ["Nullable", /Nullable needs its type/],
+    ["Enum8", /Enum8 needs at least one member/],
+    ["Array(FixedString)", /FixedString needs its length/],
+  ])("parameters that do not fit: %s", (type, detail) => {
+    expect(typeFindings(type, "test")).toEqual([{ checkId: "SQLCH122", detail: expect.stringMatching(detail) }]);
+  });
+  test("Nullable(LowCardinality(String)) (probe wrapper-order)", () => {
+    flagged("SQLCH123", { shop, events: events("id UInt64, note Nullable(LowCardinality(String))") }, /Nullable cannot hold LowCardinality; write LowCardinality\(Nullable\(T\)\) instead/);
+  });
+  test("Nullable(Array(String)) (probe wrapper-nested-nullable)", () => {
+    flagged("SQLCH123", { shop, events: events("id UInt64, tags Nullable(Array(String))") }, /Nullable cannot hold Array/);
+  });
+  test.each(["Nullable(Map(String, UInt8))", "Nullable(Nested(a UInt8))", "Nullable(Variant(String))", "Nullable(Nullable(String))", "Array(Nullable(Array(UInt8)))"])(
+    "wrappers ClickHouse refuses: %s",
+    (type) => {
+      expect(typeFindings(type, "test").map((f) => f.checkId)).toEqual(["SQLCH123"]);
+    },
+  );
+  test("view and dictionary columns are checked too", () => {
+    const v = view`CREATE MATERIALIZED VIEW ${shop}.mv (kind Strng) ENGINE = MergeTree ORDER BY kind AS SELECT 'a' AS kind`;
+    flagged("SQLCH121", { shop, v }, /v \(mv\): column kind Strng/);
+    const d = dictionary`CREATE DICTIONARY ${shop}.d (id UInt64, name Strng) PRIMARY KEY id SOURCE(CLICKHOUSE(TABLE 't')) LAYOUT(HASHED()) LIFETIME(300)`;
+    flagged("SQLCH121", { shop, d }, /column name Strng/);
+  });
+  test("a table with every correct type is clean for all three", () => {
+    const t = events(CORRECT_TYPES.map((type, i) => `c${i} ${type}`).join(", "));
+    for (const id of ["SQLCH121", "SQLCH122", "SQLCH123"]) clean(id, { shop, t });
+  });
+});
+
+describe("SQLCH124: a column declared twice", () => {
+  test("flags (id UInt64, id UInt32) (probe dup-column)", () => {
+    flagged("SQLCH124", { shop, events: events("id UInt64, id UInt32") }, /events \(events\) declares column id twice/);
+  });
+  test("distinct columns are clean", () => {
+    clean("SQLCH124", { shop, events: events("id UInt64, Id UInt32, n Nested(id UInt8)") });
+  });
+});
+
+describe("SQLCH125: codec parameters", () => {
+  test("ZSTD(99) (probe codec-bad-param)", () => {
+    flagged("SQLCH125", { shop, t2: events("id UInt64 CODEC(ZSTD(99))") }, /column id CODEC\(ZSTD\(99\)\): ZSTD level 99 is outside 1 to 22/);
+  });
+  test.each([
+    ["LZ4HC(13)", /LZ4HC level 13 is outside 0 to 12/],
+    ["Delta(3), ZSTD", /Delta bytes 3 is not one of 1, 2, 4, 8/],
+    ["DoubleDelta(16)", /DoubleDelta bytes 16 is not one of/],
+    ["Gorilla(5)", /Gorilla bytes 5/],
+    ["LZ4(1)", /LZ4 takes no parameters/],
+    ["T64('nibble')", /T64 variant 'nibble' is not one of 'byte', 'bit'/],
+  ])("flags %s", (codec, text) => {
+    flagged("SQLCH125", { shop, t: events(`id UInt64 CODEC(${codec})`) }, text);
+  });
+  test("codecs within their parameters, and unknown-parameter codecs, are clean", () => {
+    const t = events(
+      "a UInt64 CODEC(Delta, ZSTD(3)), b UInt64 CODEC(Delta(8), LZ4HC(9)), c DateTime CODEC(DoubleDelta(4), ZSTD(1, 27)), d Float64 CODEC(Gorilla, FPC(12, 8)), e UInt64 CODEC(T64('bit'), ZSTD), f String CODEC(NONE), g String CODEC(AES_128_GCM_SIV), h Float64 CODEC(ALP(1, 2, 3))",
+    );
+    clean("SQLCH125", { shop, t });
+  });
+});
+
+describe("SQLCH126: grant column lists", () => {
+  const t = table`CREATE TABLE ${shop}.events (id UInt64, kind String, n Nested(a UInt8)) ENGINE = MergeTree ORDER BY id`;
+  const r = role`CREATE ROLE analyst`;
+  test("GRANT SELECT(kindd) ON ${events} (probe grant-bad-column)", () => {
+    const g = grant`GRANT SELECT(kindd) ON ${t} TO ${r}`;
+    flagged("SQLCH126", { shop, t, r, g }, /g: GRANT SELECT\(kindd\) ON shop.events names column kindd, which t \(events\) does not declare/);
+  });
+  test("declared columns, Nested fields, and a plain-text target are clean", () => {
+    const g = grant`GRANT SELECT(id, kind, n.a), INSERT(id) ON ${t} TO ${r}`;
+    const plain = grant`GRANT SELECT(whatever) ON shop.other TO ${r}`;
+    const all = grant`GRANT SELECT ON ${t} TO ${r}`;
+    clean("SQLCH126", { shop, t, r, g, plain, all });
+  });
+});
+
+describe("SQLCH127: functions in expressions", () => {
+  test("DEFAULT noww() (probe default-function-unknown)", () => {
+    flagged("SQLCH127", { shop, events: events("id UInt64, at DateTime DEFAULT noww()") }, /events \(events\): column at DEFAULT calls noww\(\), which ClickHouse \S+ does not have/);
+  });
+  test("PARTITION BY toYYYYMMM(at) (probe function-unknown)", () => {
+    const t = table`CREATE TABLE ${shop}.events (id UInt64, at DateTime) ENGINE = MergeTree PARTITION BY toYYYYMMM(at) ORDER BY id`;
+    flagged("SQLCH127", { shop, t }, /PARTITION BY calls toYYYYMMM\(\)/);
+  });
+  test.each([
+    ["ORDER BY", "ORDER BY (id, toStartOfHourr(at))"],
+    ["PRIMARY KEY", "PRIMARY KEY lowerr(s) ORDER BY lowerr(s)"],
+    ["SAMPLE BY", "ORDER BY (id, cityHash6(id)) SAMPLE BY cityHash6(id)"],
+    ["TTL", "ORDER BY id TTL toDatee(at) + INTERVAL 1 DAY"],
+  ])("checks %s", (where, clauses) => {
+    const t = table`CREATE TABLE ${shop}.events (id UInt64, at DateTime, s String) ENGINE = MergeTree ${clauses as unknown as never}`;
+    const messages = run("SQLCH127", { shop, t }).map((d) => d.message);
+    expect(messages).toContainEqual(expect.stringContaining(`${where} calls`));
+  });
+  test("checks MATERIALIZED, ALIAS, EPHEMERAL, a column TTL and a skip index", () => {
+    const t = events(
+      "id UInt64, a UInt64 MATERIALIZED fooo(id), b UInt64 ALIAS barr(id), c UInt64 EPHEMERAL bazz(1), at DateTime TTL quxx(at), INDEX k zapp(id) TYPE minmax GRANULARITY 1",
+    );
+    const messages = run("SQLCH127", { shop, t }).map((d) => d.message);
+    expect(messages).toEqual([
+      expect.stringContaining("column a MATERIALIZED calls fooo()"),
+      expect.stringContaining("column b ALIAS calls barr()"),
+      expect.stringContaining("column c EPHEMERAL calls bazz()"),
+      expect.stringContaining("column at TTL calls quxx()"),
+      expect.stringContaining("index k calls zapp()"),
+    ]);
+  });
+  test("catalog functions, aliases, combinators, keywords, lambdas, strings and func UDFs are clean", () => {
+    const f = func`CREATE FUNCTION normalizeKind AS (k) -> lower(trim(k))`;
+    const t = table`CREATE TABLE ${shop}.events (
+      id UInt64,
+      at DateTime DEFAULT now(),
+      at64 DateTime64(3) DEFAULT now64(3),
+      d Date DEFAULT toDate(at),
+      day Date MATERIALIZED DATE_TRUNC('day', at),
+      day2 Date MATERIALIZED date_trunc('day', at),
+      u UUID DEFAULT generateUUIDv4(),
+      s String DEFAULT 'not_a_call(x)',
+      k String DEFAULT normalizeKind(s),
+      c UInt64 DEFAULT CAST(1 AS UInt64),
+      t Tuple(UInt8, UInt8) DEFAULT tuple(1, 2),
+      i UInt8 DEFAULT if(id > 0, 1, 0),
+      y UInt16 DEFAULT EXTRACT(YEAR FROM at),
+      tr String DEFAULT TRIM(BOTH ' ' FROM s),
+      sub String ALIAS SUBSTRING(s, 1, 2),
+      dd Int64 ALIAS DATE_DIFF('day', at, now()),
+      inl UInt8 ALIAS id IN (1, 2),
+      arr Array(UInt64) DEFAULT arrayMap(x -> x * 2, [id]),
+      cnt UInt64 ALIAS COUNT(),
+      q String ALIAS \`weird(name)\`,
+      m Map(String, UInt8) DEFAULT map('a', 1),
+      INDEX ix lower(s) TYPE bloom_filter GRANULARITY 1
+    ) ENGINE = MergeTree PARTITION BY toYYYYMM(at) ORDER BY (id, cityHash64(id)) SAMPLE BY cityHash64(id)
+      TTL at + INTERVAL 1 DAY RECOMPRESS CODEC(ZSTD(17)), at + toIntervalMonth(1) DELETE`;
+    clean("SQLCH127", { shop, f, t });
+  });
+  test("combinators resolve to their aggregate", () => {
+    for (const name of ["countIf", "sumState", "uniqMerge", "argMaxIf", "sumIfState", "quantilesMergeState", "anyLastSimpleState", "sumForEach", "uniqExactOrNull", "COUNTIf"]) {
+      expect(isKnownFunction(name), name).toBe(true);
+    }
+    for (const name of ["noww", "toYYYYMMIf", "nowState", "State", "Merge"]) expect(isKnownFunction(name), name).toBe(false);
+  });
+  test("only an identifier followed by ( outside strings and quoted names is a call", () => {
+    expect(calledNames("f(x) + 'g(y)' + `h(z)` + t.k(1) + x IN (1) + EXISTS(1) + ARRAY(1) + INTERVAL (1) DAY")).toEqual(["f"]);
+  });
+});
+
+describe("SQL101: an object declared twice", () => {
+  test("two exports of shop.events (probe dup-table)", () => {
+    const a = table`CREATE TABLE ${shop}.events (id UInt64) ENGINE = MergeTree ORDER BY id`;
+    const b = table`CREATE TABLE ${shop}.events (id UInt64) ENGINE = MergeTree ORDER BY id`;
+    const d = flagged("SQL101", { shop, a, b }, /^a and b both declare ClickHouse table shop.events/);
+    expect(d.entity).toBe("b");
+  });
+  test("two exports of app.orders, Postgres", () => {
+    const app = schema`CREATE SCHEMA app`;
+    const a = pgTable`CREATE TABLE ${app}.orders (id bigint PRIMARY KEY)`;
+    const b = pgTable`CREATE TABLE ${app}.orders (id bigint PRIMARY KEY)`;
+    flagged("SQL101", { app, a, b }, /a and b both declare Postgres table/);
+  });
+  test("one name across kinds or databases, and distinct objects, are clean", () => {
+    const other = database`CREATE DATABASE other ENGINE = Atomic`;
+    const a = table`CREATE TABLE ${shop}.events (id UInt64) ENGINE = MergeTree ORDER BY id`;
+    const b = table`CREATE TABLE ${other}.events (id UInt64) ENGINE = MergeTree ORDER BY id`;
+    const r = role`CREATE ROLE analyst`;
+    const g1 = grant`GRANT SELECT ON ${a} TO ${r}`;
+    const g2 = grant`GRANT SELECT ON ${b} TO ${r}`;
+    clean("SQL101", { shop, other, a, b, r, g1, g2 });
+    const app = schema`CREATE SCHEMA app`;
+    const mood = pgType`CREATE TYPE ${app}.mood AS ENUM ('a')`;
+    const orders = pgTable`CREATE TABLE ${app}.orders (id bigint PRIMARY KEY)`;
+    const lines = pgTable`CREATE TABLE ${app}.lines (id bigint PRIMARY KEY)`;
+    clean("SQL101", { app, mood, orders, lines });
+  });
+});

package/src/lint/post-synth/clickhouse-type-check.ts

@@ -0,0 +1,173 @@
+/**
+ * Checking a ClickHouse column type against the pinned catalog, for SQLCH121
+ * (the family), SQLCH122 (its parameters) and SQLCH123 (a wrapper the server
+ * refuses). One walk over the type answers all three; each check keeps the
+ * findings with its own id.
+ *
+ * Families come from `system.data_type_families` (`TYPE_FAMILIES`): a name is
+ * case-sensitive unless the catalog marks it case-insensitive, and an alias
+ * resolves to its family. Parameters come from the `TYPE_PARAMETERS` overlay.
+ * The walk goes into every parameter that is itself a type, so `UInt46`
+ * inside `Array(Map(String, UInt46))` is found.
+ */
+
+import { CLICKHOUSE_VERSION, TYPE_FAMILIES } from "../../generated/clickhouse";
+import { TYPE_PARAMETERS, type TypeParameter } from "../../clickhouse/overlays/types";
+import { numericParam, readType, typeTokens, type TypeParam } from "../../clickhouse/type-syntax";
+import type { Token } from "../../clickhouse/tokens";
+import { checkOf } from "./clickhouse-helpers";
+import { clickhouseObjects, type OutputObject } from "./sql-helpers";
+
+export interface TypeFinding {
+  checkId: "SQLCH121" | "SQLCH122" | "SQLCH123";
+  /** What is wrong, without the column: `UInt46 is not a type family ClickHouse 26.8.15.10 has`. */
+  detail: string;
+}
+
+type FamilySpec = { canonical: string; caseInsensitive: boolean };
+const FAMILIES = TYPE_FAMILIES as Readonly<Record<string, FamilySpec | undefined>>;
+const FOLDED = new Map<string, FamilySpec>();
+const BY_LOWER = new Map<string, string>();
+for (const [name, spec] of Object.entries(FAMILIES)) {
+  if (spec?.caseInsensitive) FOLDED.set(name.toLowerCase(), spec);
+  BY_LOWER.set(name.toLowerCase(), name);
+}
+
+/** A family by name as the server resolves it: exactly, or in any case when the catalog marks it case-insensitive. */
+export function familyOf(name: string): FamilySpec | undefined {
+  return FAMILIES[name] ?? FOLDED.get(name.toLowerCase());
+}
+
+/** The MySQL-compatible words the parser keeps after a type (`INT(11) UNSIGNED`); the server ignores them. */
+const MODIFIERS = new Set(["UNSIGNED", "SIGNED", "AUTO_INCREMENT", "ZEROFILL"]);
+
+/**
+ * What `Nullable(...)` cannot hold. `Tuple` is not here: the pinned server
+ * takes `Nullable(Tuple(...))` when `enable_nullable_tuple_type` is on, a
+ * setting of the server's profile that the build cannot see.
+ */
+const NOT_INSIDE_NULLABLE: Record<string, string> = {
+  Array: "make the elements Nullable instead, Array(Nullable(T)), or drop Nullable: an empty array stands for no value",
+  Map: "make the values Nullable instead, Map(K, Nullable(V)), or drop Nullable",
+  Nested: "make the fields Nullable instead",
+  LowCardinality: "write LowCardinality(Nullable(T)) instead",
+  Variant: "drop Nullable: a Variant already holds NULL",
+  Nullable: "drop one Nullable",
+};
+
+/** Families whose parameters are settings or expressions rather than types and literals; left to the server. */
+const OPAQUE = new Set(["JSON", "Dynamic"]);
+
+/** Families whose one repeated parameter needs at least one value. */
+const NEEDS_ONE = new Set(["Enum", "Enum8", "Enum16", "Nested", "Variant"]);
+
+const isName = (t: Token | undefined) => t?.kind === "ident" || t?.kind === "qident";
+
+/** Every finding for one column type, in the order the walk meets them. */
+export function typeFindings(type: string, version: string): TypeFinding[] {
+  const tokens = typeTokens(type);
+  if (!tokens) return [];
+  const out: TypeFinding[] = [];
+  walk(tokens, version, out);
+  return out;
+}
+
+function walk(tokens: readonly Token[], version: string, out: TypeFinding[], named = false): string | undefined {
+  const syntax = readType(tokens);
+  if (!syntax) return undefined;
+  let words = syntax.words;
+  // A named tuple or Nested element, `a String`: the first word is the element's name.
+  if (named && words.length >= 2 && !familyOf(words.map((w) => w.text).join(" "))) {
+    const at = tokens.indexOf(words[0]!);
+    return walk(tokens.slice(at + 1), version, out);
+  }
+  if (words.some((w) => w.kind !== "ident")) return undefined;
+  // `INT UNSIGNED` is a family of its own; `Int32 UNSIGNED` is Int32 with a modifier the server ignores.
+  let spec = familyOf(words.map((w) => w.text).join(" "));
+  while (!spec && words.length > 1 && MODIFIERS.has(words[words.length - 1]!.text.toUpperCase())) {
+    words = words.slice(0, -1);
+    spec = familyOf(words.map((w) => w.text).join(" "));
+  }
+  const written = words.map((w) => w.text).join(" ");
+  if (!spec) {
+    const other = BY_LOWER.get(written.toLowerCase());
+    const hint = other ? ` (it has ${other}, and that name is case-sensitive)` : "";
+    out.push({ checkId: "SQLCH121", detail: `${written} is not a type family ClickHouse ${version} has${hint}` });
+    return undefined;
+  }
+  const family = spec.canonical;
+  if (OPAQUE.has(family)) return family;
+  const expected: readonly TypeParameter[] = TYPE_PARAMETERS[family] ?? [];
+  let params = syntax.params;
+  const say = (detail: string) => out.push({ checkId: "SQLCH122", detail });
+
+  if (params === undefined) {
+    const required = expected.filter((p) => !p.optional && !p.repeated);
+    if (required.length > 0) say(`${written} needs its ${required.map((p) => p.name).join(" and ")}`);
+    else if (NEEDS_ONE.has(family)) say(`${written} needs at least one ${expected[0]!.name}`);
+    return family;
+  }
+  // `AggregateFunction(1, uniq, UInt64)`: a leading number is the function's state version.
+  if (family === "AggregateFunction" && params[0] && numericParam(params[0]) !== undefined) params = params.slice(1);
+
+  if (expected.length === 0) {
+    if (params.length > 0) say(`${written} takes no parameters, and ${written}(${params.map((p) => p.text).join(", ")}) gives ${params.length}`);
+    return family;
+  }
+  const repeated = expected[expected.length - 1]!.repeated === true;
+  if (!repeated && params.length > expected.length) {
+    say(`${written} takes at most ${expected.length} parameter${expected.length === 1 ? "" : "s"} (${expected.map((p) => p.name).join(", ")}), and is given ${params.length}`);
+    return family;
+  }
+  const required = expected.filter((p) => !p.optional && !p.repeated).length;
+  if (params.length < required) {
+    say(`${written} needs its ${expected.slice(params.length, required).map((p) => p.name).join(" and ")}`);
+    return family;
+  }
+  if (params.length === 0 && NEEDS_ONE.has(family)) {
+    say(`${written} needs at least one ${expected[0]!.name}`);
+    return family;
+  }
+
+  params.forEach((param, i) => {
+    const p = expected[Math.min(i, expected.length - 1)]!;
+    checkParam(written, family, p, param, version, out);
+  });
+  return family;
+}
+
+function checkParam(written: string, family: string, p: TypeParameter, param: TypeParam, version: string, out: TypeFinding[]): void {
+  if (p.kind === "number" && p.range) {
+    const value = numericParam(param);
+    if (value !== undefined && (value < p.range[0] || value > p.range[1])) {
+      out.push({ checkId: "SQLCH122", detail: `${written} ${p.name} ${param.text} is outside ${p.range[0]} to ${p.range[1]}` });
+    }
+    return;
+  }
+  if (p.kind !== "type" && p.kind !== "named-type") return;
+  const inner = walk(param.tokens, version, out, p.kind === "named-type" && isName(param.tokens.find((t) => t.kind !== "ws" && t.kind !== "comment")));
+  if (family === "Nullable" && inner !== undefined && NOT_INSIDE_NULLABLE[inner]) {
+    out.push({ checkId: "SQLCH123", detail: `Nullable cannot hold ${inner}; ${NOT_INSIDE_NULLABLE[inner]}` });
+  }
+}
+
+/** Each declared column type in the build: tables, views that list their columns, and dictionary attributes. */
+export function* columnTypes(objects: readonly OutputObject[]): Generator<{ object: OutputObject; column: string; type: string }> {
+  for (const o of objects) {
+    if (!/^ClickHouse::(Table|View|MaterializedView|Dictionary)$/.test(o.type)) continue;
+    const columns = (o.columns ?? []) as Array<{ name: string; type?: string }>;
+    for (const c of columns) if (c.type) yield { object: o, column: c.name, type: c.type };
+  }
+}
+
+/** The body of one of the three type checks: every column type's findings with that id. */
+export function reportTypeFindings(id: TypeFinding["checkId"]): Parameters<typeof checkOf>[1] {
+  return (ctx, report) => {
+    for (const { object, column, type } of columnTypes(clickhouseObjects(ctx))) {
+      for (const f of typeFindings(type, CLICKHOUSE_VERSION)) {
+        if (f.checkId !== id) continue;
+        report({ severity: "error", message: `${object.export} (${object.name}): column ${column} ${type}: ${f.detail}`, entity: object.export });
+      }
+    }
+  };
+}

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

@@ -1,5 +1,6 @@
 // Code generated by chant generate. DO NOT EDIT.
 import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+import { sql101 } from "./sql101";
 import { sqlch101 } from "./sqlch101";
 import { sqlch102 } from "./sqlch102";
 import { sqlch103 } from "./sqlch103";
@@ -20,6 +21,13 @@ import { sqlch117 } from "./sqlch117";
 import { sqlch118 } from "./sqlch118";
 import { sqlch119 } from "./sqlch119";
 import { sqlch120 } from "./sqlch120";
+import { sqlch121 } from "./sqlch121";
+import { sqlch122 } from "./sqlch122";
+import { sqlch123 } from "./sqlch123";
+import { sqlch124 } from "./sqlch124";
+import { sqlch125 } from "./sqlch125";
+import { sqlch126 } from "./sqlch126";
+import { sqlch127 } from "./sqlch127";
 import { sqlpg101 } from "./sqlpg101";
 import { sqlpg102 } from "./sqlpg102";
 import { sqlpg103 } from "./sqlpg103";
@@ -38,8 +46,17 @@ import { sqlpg115 } from "./sqlpg115";
 import { sqlpg116 } from "./sqlpg116";
 import { sqlpg117 } from "./sqlpg117";
 import { sqlpg118 } from "./sqlpg118";
+import { sqlpg119 } from "./sqlpg119";
+import { sqlpg120 } from "./sqlpg120";
+import { sqlpg121 } from "./sqlpg121";
+import { sqlpg122 } from "./sqlpg122";
+import { sqlpg123 } from "./sqlpg123";
+import { sqlpg124 } from "./sqlpg124";
+import { sqlpg125 } from "./sqlpg125";
+import { sqlpg126 } from "./sqlpg126";
 
 export const postSynthChecks: PostSynthCheck[] = [
+  sql101,
   sqlch101,
   sqlch102,
   sqlch103,
@@ -60,6 +77,13 @@ export const postSynthChecks: PostSynthCheck[] = [
   sqlch118,
   sqlch119,
   sqlch120,
+  sqlch121,
+  sqlch122,
+  sqlch123,
+  sqlch124,
+  sqlch125,
+  sqlch126,
+  sqlch127,
   sqlpg101,
   sqlpg102,
   sqlpg103,
@@ -78,4 +102,12 @@ export const postSynthChecks: PostSynthCheck[] = [
   sqlpg116,
   sqlpg117,
   sqlpg118,
+  sqlpg119,
+  sqlpg120,
+  sqlpg121,
+  sqlpg122,
+  sqlpg123,
+  sqlpg124,
+  sqlpg125,
+  sqlpg126,
 ];

package/src/lint/post-synth/postgres-audit-entries.ts

@@ -26,4 +26,12 @@ export const postgresPostSynthAuditEntries: Record<string, RuleMeta> = {
   SQLPG116: auditRule("SQLPG116", "merge-worthy", "guidance", "An extension the target major no longer ships", "Remove the extension, or set sql.postgresMajor to an older major.", { category: "best-practice" }),
   SQLPG117: auditRule("SQLPG117", "report-only", "guidance", "A view without security_invoker runs with its owner's privileges", "Set security_invoker = true in the view's WITH options.", { category: "security" }),
   SQLPG118: auditRule("SQLPG118", "report-only", "guidance", "A table uses INHERITS where declarative partitioning replaced it", "Use PARTITION BY and PARTITION OF.", { category: "best-practice" }),
+  SQLPG119: auditRule("SQLPG119", "merge-worthy", "guidance", "A column, domain or sequence type the target major does not have", "Fix the type name, declare the type, or declare the extension that provides it.", { category: "correctness" }),
+  SQLPG120: auditRule("SQLPG120", "merge-worthy", "guidance", "A type modifier that does not fit the type", "Drop the modifier, or bring it into the type's range.", { category: "correctness" }),
+  SQLPG121: auditRule("SQLPG121", "merge-worthy", "guidance", "An identity column whose type is not smallint, integer or bigint", "Declare the identity column smallint, integer or bigint.", { category: "correctness" }),
+  SQLPG122: auditRule("SQLPG122", "merge-worthy", "guidance", "A table declares a column twice, or an enum lists a label twice", "Remove or rename the repeated column or label.", { category: "correctness" }),
+  SQLPG123: auditRule("SQLPG123", "merge-worthy", "guidance", "A key, index or grant column list names a column the table does not declare", "Fix the column name, or write it as ${table.columns.name}.", { category: "correctness" }),
+  SQLPG124: auditRule("SQLPG124", "merge-worthy", "guidance", "A foreign key names a column the referenced table lacks, or one of another type category", "Reference a declared column, and give the referencing column a type of the same category.", { category: "correctness" }),
+  SQLPG125: auditRule("SQLPG125", "merge-worthy", "guidance", "An index access method or operator class the target major does not have, or not for that method", "Use a method and operator class the target major has, or declare the extension that provides them.", { category: "correctness" }),
+  SQLPG126: auditRule("SQLPG126", "merge-worthy", "guidance", "An expression calls a function the target major does not have", "Fix the function name, declare the function, or declare the extension that provides it.", { category: "correctness" }),
 };