@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.0

package/src/clickhouse/overlays/projections.ts

@@ -0,0 +1,36 @@
+/**
+ * Projections: the overlay half.
+ *
+ * `system.table_engines.supports_projections` says which engines accept a
+ * projection, and is generated. The projection's own grammar is fixed and in
+ * no table: a name and a parenthesised query over the table, either a
+ * reordering (`SELECT * ORDER BY x`) or an aggregation (`SELECT k, sum(v)
+ * GROUP BY k`). `system.projections` is runtime state, not grammar.
+ *
+ *     PROJECTION name (SELECT <columns or *> [GROUP BY ...] [ORDER BY ...])
+ */
+
+export interface ProjectionForm {
+  form: "normal" | "aggregate";
+  /** The clause that makes a projection this form. */
+  marker: "ORDER BY" | "GROUP BY";
+  summary: string;
+}
+
+export const PROJECTION_FORMS: readonly ProjectionForm[] = [
+  { form: "normal", marker: "ORDER BY", summary: "A copy of the selected columns in another sort order." },
+  { form: "aggregate", marker: "GROUP BY", summary: "Pre-aggregated rows, kept current by merges like an AggregatingMergeTree." },
+];
+
+/**
+ * MergeTree settings that decide what a mutation or deduplicating merge does to
+ * a table with projections. Changing either is metadata only; leaving them at
+ * their defaults makes `ALTER ... UPDATE` on such a table an error.
+ */
+export const PROJECTION_SETTINGS: readonly string[] = [
+  "deduplicate_merge_projection_mode",
+  "lightweight_mutation_projection_mode",
+];
+
+/** Clauses a projection's query may not carry. */
+export const PROJECTION_FORBIDDEN_CLAUSES: readonly string[] = ["WHERE", "JOIN", "LIMIT", "HAVING", "ARRAY JOIN"];

package/src/clickhouse/overlays/skip-indexes.ts

@@ -0,0 +1,44 @@
+/**
+ * Skip index parameters: the overlay half.
+ *
+ * `system.data_skipping_index_types` names each type and gives a syntax line,
+ * from which the generator reads parameter names and optionality. This adds
+ * their kinds and ranges. `GRANULARITY` is fixed grammar the parser owns.
+ */
+
+import type { ArgumentOverlay } from "./kinds";
+
+const HASHES: ArgumentOverlay = { kind: "number", range: [1, 1_000_000], note: "Hash functions per value." };
+const BYTES: ArgumentOverlay = { kind: "number", note: "Bloom filter size in bytes." };
+const SEED: ArgumentOverlay = { kind: "number", note: "Seed for the hash functions." };
+
+export const SKIP_INDEX_PARAMETERS: Record<string, Record<string, ArgumentOverlay>> = {
+  bloom_filter: {
+    false_positive_rate: { kind: "number", range: [0, 1], note: "Exclusive of 0 and 1; 0.025 when omitted." },
+  },
+  set: { max_rows: { kind: "number", note: "0 keeps every distinct value." } },
+  ngrambf_v1: {
+    n: { kind: "number", range: [1, 256], note: "N-gram size." },
+    size_in_bytes: BYTES,
+    num_hash_functions: HASHES,
+    seed: SEED,
+  },
+  tokenbf_v1: { size_in_bytes: BYTES, num_hash_functions: HASHES, seed: SEED },
+  sparse_grams: {
+    min_ngram_length: { kind: "number" },
+    max_ngram_length: { kind: "number" },
+    min_cutoff_length: { kind: "number" },
+    size_in_bytes: BYTES,
+    num_hash_functions: HASHES,
+    seed: SEED,
+  },
+  text: { tokenizer: { kind: "expression", note: "A tokenizer such as splitByNonAlpha, ngrams(N) or array." } },
+  vector_similarity: {
+    hnsw: { kind: "keyword", values: ["hnsw"], note: "The only method." },
+    distance_function: { kind: "keyword", values: ["L2Distance", "cosineDistance"] },
+    dimensions: { kind: "number" },
+    quantization: { kind: "keyword", values: ["f64", "f32", "f16", "bf16", "i8", "b1"] },
+    hnsw_max_connections_per_layer: { kind: "number" },
+    hnsw_candidate_list_size_for_construction: { kind: "number" },
+  },
+};

package/src/clickhouse/overlays/ttl.ts

@@ -0,0 +1,55 @@
+/**
+ * TTL clauses: the whole grammar is overlay.
+ *
+ * No system table describes TTL. A table TTL is a list of rules, each an
+ * expression evaluating to a `Date` or `DateTime` and an action; a column TTL
+ * is a single expression with no action, after which the column resets to its
+ * default. Which engines accept TTL at all is generated
+ * (`capabilities.ttl` from `system.table_engines.supports_ttl`).
+ *
+ *     TTL expr [DELETE | RECOMPRESS codec | TO DISK 'd' | TO VOLUME 'v'] [WHERE cond]
+ *         [, expr GROUP BY key_columns SET col = agg(col), ...]
+ */
+
+import type { ArgumentOverlay } from "./kinds";
+
+export interface TtlAction {
+  /** The keywords that open the action, as written. */
+  keywords: string;
+  /** What follows the keywords. */
+  argument?: ArgumentOverlay;
+  /** Whether a trailing `WHERE cond` may filter the rows it applies to. */
+  where: boolean;
+  /**
+   * What the server's `SHOW CREATE` prints when the action is written as the
+   * default. A declared `TTL ts + INTERVAL 1 DAY DELETE` reads back with
+   * `DELETE` dropped, so a comparison must treat the two as one.
+   */
+  impliedWhenOmitted?: boolean;
+}
+
+export const TTL_ACTIONS: readonly TtlAction[] = [
+  { keywords: "DELETE", where: true, impliedWhenOmitted: true },
+  { keywords: "RECOMPRESS", argument: { kind: "codec", note: "A CODEC(...) expression." }, where: true },
+  { keywords: "TO DISK", argument: { kind: "string", note: "A disk of the table's storage policy." }, where: true },
+  { keywords: "TO VOLUME", argument: { kind: "string", note: "A volume of the table's storage policy." }, where: true },
+  {
+    keywords: "GROUP BY",
+    argument: { kind: "columns", note: "A prefix of the sort key, then SET col = aggregate(col), ..." },
+    where: true,
+  },
+];
+
+/** A column TTL takes an expression and nothing else. */
+export const COLUMN_TTL_ACTIONS: readonly TtlAction[] = [];
+
+/** The types a TTL expression must evaluate to. */
+export const TTL_RESULT_TYPES: readonly string[] = ["Date", "Date32", "DateTime", "DateTime64"];
+
+/** MergeTree settings that change how TTL runs, for lint and hover to point at. */
+export const TTL_SETTINGS: readonly string[] = [
+  "merge_with_ttl_timeout",
+  "merge_with_recompression_ttl_timeout",
+  "ttl_only_drop_parts",
+  "materialize_ttl_recalculate_only",
+];

package/src/clickhouse/overlays/types.ts

@@ -0,0 +1,58 @@
+/**
+ * Column type parameters: the overlay half.
+ *
+ * `system.data_type_families` lists the families and their aliases. The
+ * parameter grammar (`Decimal(P, S)`, `DateTime64(precision[, tz])`,
+ * `Enum8('a' = 1)`) is in no system table. A family missing here takes no
+ * parameters; generation fails when a key here is not a family at the pin.
+ */
+
+import type { ArgumentKind } from "./kinds";
+
+export interface TypeParameter {
+  name: string;
+  kind: ArgumentKind | "enum-member" | "named-type";
+  optional?: boolean;
+  /** The parameter repeats (`Tuple(T, ...)`). */
+  repeated?: boolean;
+  range?: readonly [number, number];
+}
+
+const P = (name: string, kind: TypeParameter["kind"], extra: Partial<TypeParameter> = {}): TypeParameter => ({
+  name,
+  kind,
+  ...extra,
+});
+
+const TZ = P("timezone", "string", { optional: true });
+
+export const TYPE_PARAMETERS: Record<string, readonly TypeParameter[]> = {
+  Decimal: [P("precision", "number", { range: [1, 76] }), P("scale", "number", { optional: true })],
+  Decimal32: [P("scale", "number", { range: [0, 9] })],
+  Decimal64: [P("scale", "number", { range: [0, 18] })],
+  Decimal128: [P("scale", "number", { range: [0, 38] })],
+  Decimal256: [P("scale", "number", { range: [0, 76] })],
+  DateTime: [TZ],
+  DateTime32: [TZ],
+  DateTime64: [P("precision", "number", { range: [0, 9] }), TZ],
+  Time64: [P("precision", "number", { range: [0, 9] })],
+  FixedString: [P("length", "number", { range: [1, Number.MAX_SAFE_INTEGER] })],
+  Enum: [P("member", "enum-member", { repeated: true })],
+  Enum8: [P("member", "enum-member", { repeated: true })],
+  Enum16: [P("member", "enum-member", { repeated: true })],
+  Nullable: [P("type", "type")],
+  LowCardinality: [P("type", "type")],
+  Array: [P("type", "type")],
+  Map: [P("key", "type"), P("value", "type")],
+  Tuple: [P("element", "named-type", { repeated: true })],
+  Nested: [P("field", "named-type", { repeated: true })],
+  Variant: [P("type", "type", { repeated: true })],
+  AggregateFunction: [P("function", "function"), P("argument", "type", { repeated: true })],
+  SimpleAggregateFunction: [P("function", "function"), P("argument", "type")],
+  JSON: [P("setting", "expression", { optional: true, repeated: true })],
+  Dynamic: [P("max_types", "expression", { optional: true })],
+  QBit: [P("element", "type"), P("dimension", "number")],
+};
+
+/** Families that wrap another type and pass its nullability and sort-key rules through. */
+export const WRAPPER_TYPES: readonly string[] = ["LowCardinality"];

package/src/clickhouse/ownership.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "vitest";
+import { isChantWorkingObject, isRebuildObject, stampedComment, stripMarkerFromStatement } from "./ownership";
+
+describe("the comment marker on ClickHouse (#3208)", () => {
+  test("comes off a printed statement, the whole clause when the comment was the marker alone", () => {
+    expect(stripMarkerFromStatement("CREATE TABLE a.t\n(\n    `id` UInt64\n)\nENGINE = Log\nCOMMENT 'Raw [chant managed-by=chant stack=s]'")).toBe(
+      "CREATE TABLE a.t\n(\n    `id` UInt64\n)\nENGINE = Log\nCOMMENT 'Raw'",
+    );
+    expect(stripMarkerFromStatement("CREATE VIEW a.v\n(\n    `id` UInt64\n)\nCOMMENT '[chant managed-by=chant]'\nAS SELECT id\nFROM a.t")).toBe(
+      "CREATE VIEW a.v\n(\n    `id` UInt64\n)\nAS SELECT id\nFROM a.t",
+    );
+  });
+
+  test("marks a rebuild's working objects and the receipts table as chant's own", () => {
+    expect(isRebuildObject(stampedComment("", { stack: "s" }, { rebuild: "db.t", role: "new" }))).toBe(true);
+    expect(isChantWorkingObject(stampedComment("", { stack: "s" }, { receipts: "effects" }))).toBe(true);
+    expect(isChantWorkingObject(stampedComment("Raw", { stack: "s" }))).toBe(false);
+    expect(isChantWorkingObject("Raw [chant managed-by=someone-else rebuild=db.t]")).toBe(false);
+  });
+});

package/src/clickhouse/ownership.ts

@@ -0,0 +1,103 @@
+/**
+ * chant's ownership marker on ClickHouse objects (#3208): a trailer on the
+ * object's own `COMMENT`.
+ *
+ * ClickHouse objects carry no tags or labels. The channels considered:
+ *
+ * - The object `COMMENT`. Every object kind has one (a table of any engine, a
+ *   view, a materialized view, a database), it is set in the `CREATE` itself
+ *   so an object is never created unmarked, `MODIFY COMMENT` restamps it, and
+ *   `system.tables` / `system.databases` return it with the catalog read
+ *   observation already makes. The #3046 candidate.
+ * - Table `SETTINGS`: a MergeTree table refuses a setting it does not know.
+ * - A registry table on the server naming the objects chant created: a record
+ *   apart from the object, which is the state file chant does not keep, and
+ *   one that goes on claiming a table someone dropped and created again.
+ *
+ * So the comment, and the question is the user's own comment, which is a
+ * declared property (`COMMENT 'Raw events'`, classified by SQLCH203). The
+ * marker never replaces it: it is appended as a bracketed trailer,
+ *
+ *     COMMENT 'Raw events [chant managed-by=chant stack=shop env=prod]'
+ *
+ * and taken off again wherever chant reads a definition (`readLiveSchema`
+ * strips it from `SHOW CREATE`), so planning, the deep diff and import compare
+ * and write the declared comment alone. Someone who edits the comment by hand
+ * and drops the trailer makes the object read as foreign, which is the safe
+ * direction: it is never pruned, and the next apply of its declaration
+ * stamps it again.
+ *
+ * Values are percent-encoded outside `[A-Za-z0-9._-]`, so the trailer never
+ * holds a quote, a backslash, a space or a bracket of its own.
+ *
+ * The trailer itself is the shared core's (`../core/ownership.ts`), the same in
+ * every dialect. What is ClickHouse's here: the channel the plugin declares,
+ * taking the trailer off a printed `COMMENT '...'` clause, and the trailer keys
+ * of the rebuild migration's working objects.
+ */
+
+import type { ChannelKeys, OwnershipChannel } from "@intentius/chant/ownership";
+import { COMMENT_OWNERSHIP_KEYS, RECEIPTS_TRAILER_KEY, TRAILER_PAIR, hasChantTrailerKey } from "../core/ownership";
+
+export {
+  carriesMarker,
+  isChantManaged,
+  markerTrailer,
+  readMarker,
+  readTrailerPairs,
+  RECEIPTS_TRAILER_KEY,
+  stampedComment,
+  stripMarker,
+  type CommentMarker,
+} from "../core/ownership";
+
+/** The keys inside the trailer. */
+export const CLICKHOUSE_COMMENT_OWNERSHIP_KEYS: ChannelKeys = COMMENT_OWNERSHIP_KEYS;
+
+/**
+ * Where the marker is read back (#1348): `describeResources` and
+ * `exportResources` read the comment from `system.tables` and
+ * `system.databases`. The deep read takes it off with the rest of `SHOW CREATE`
+ * and reports no verdict.
+ */
+export const SQL_OWNERSHIP_CHANNEL: OwnershipChannel = {
+  keys: CLICKHOUSE_COMMENT_OWNERSHIP_KEYS,
+  reads: ["describeResources", "exportResources"],
+};
+
+/** A comment that is the trailer alone, in a printed statement: the whole `COMMENT '...'` clause. */
+const ONLY_TRAILER_CLAUSE = new RegExp(`\\s*\\bCOMMENT\\s+'\\[chant(?: ${TRAILER_PAIR})+\\]'`, "g");
+/** The trailer inside a printed comment literal, just before its closing quote. */
+const TRAILER_IN_LITERAL = new RegExp(`\\s+\\[chant(?: ${TRAILER_PAIR})+\\]'`, "g");
+
+/**
+ * The trailer key naming the table a rebuild migration object belongs to
+ * (`./rebuild/`). An object carrying it is the rebuild's own working object,
+ * not a declaration: a new table being filled, the dual-write view, an old
+ * table being retained. Reading a schema leaves those out
+ * (`./live/catalog.ts`), so a plan, an import or a prune never sees them.
+ */
+export const REBUILD_TRAILER_KEY = "rebuild";
+
+/** Whether a comment marks a rebuild migration's working object. */
+export function isRebuildObject(comment: string | undefined): boolean {
+  return hasChantTrailerKey(comment, [REBUILD_TRAILER_KEY]);
+}
+
+/**
+ * Whether a comment marks one of chant's own working objects: a rebuild's
+ * new, dual-write or retained table, or the receipts database and table.
+ * Schema reads leave them out.
+ */
+export function isChantWorkingObject(comment: string | undefined): boolean {
+  return hasChantTrailerKey(comment, [REBUILD_TRAILER_KEY, RECEIPTS_TRAILER_KEY]);
+}
+
+/**
+ * A `SHOW CREATE` statement with the trailer taken off its object comment, so
+ * the statement reads as the declaration it came from. A comment that was the
+ * trailer alone loses its whole `COMMENT` clause.
+ */
+export function stripMarkerFromStatement(statement: string): string {
+  return statement.replace(ONLY_TRAILER_CLAUSE, "").replace(TRAILER_IN_LITERAL, "'");
+}

package/src/clickhouse/parser.test.ts

@@ -0,0 +1,166 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { parseCreate, type TableNode, type ViewNode } from "./parser";
+import { SqlSyntaxError, tokenize, tokenizeText, untokenize } from "./tokens";
+
+const parse = (sql: string) => parseCreate(tokenizeText(sql, 0));
+const text = (sql: string, span?: { from: number; to: number }) =>
+  span ? untokenize(tokenizeText(sql, 0).slice(span.from, span.to), () => "?").trim() : undefined;
+
+describe("tokenizing a template", () => {
+  test("is lossless: tokens give the raw text back, comments and spacing included", () => {
+    const parts = ["CREATE TABLE t (\n  id UInt64, -- the key\n  /* block */ x ", " DEFAULT 'a''b'\n) ENGINE = Log"];
+    expect(untokenize(tokenize(parts), (i) => "${" + i + "}")).toBe(parts.join("${0}"));
+  });
+
+  test("a name may start with a digit", () => {
+    const node = parse("CREATE TABLE 00662_has_nullable (a UInt8) ENGINE = Memory") as TableNode;
+    expect(node.columns[0]!.name).toBe("a");
+  });
+
+  test("an unterminated quote is located", () => {
+    expect(() => tokenizeText("CREATE TABLE t (a String DEFAULT 'x) ENGINE = Log", 0)).toThrow(SqlSyntaxError);
+  });
+});
+
+describe("parsing CREATE TABLE", () => {
+  const sql = `CREATE TABLE IF NOT EXISTS db.events ON CLUSTER main (
+    user_id UUID,
+    kind LowCardinality(String) DEFAULT 'click' COMMENT 'what happened',
+    ts DateTime64(3, 'UTC') CODEC(Delta, ZSTD(3)) TTL ts + INTERVAL 1 DAY,
+    tags Array(String) DEFAULT ['a', 'b'],
+    n Nullable(UInt32),
+    total UInt64 MATERIALIZED n * 2,
+    INDEX k kind TYPE bloom_filter(0.01) GRANULARITY 4,
+    PROJECTION by_kind (SELECT kind, count() GROUP BY kind),
+    CONSTRAINT c CHECK n > 0,
+  )
+  ENGINE = ReplicatedReplacingMergeTree('/t/{shard}', '{replica}', ts)
+  PARTITION BY toYYYYMM(ts)
+  ORDER BY (user_id, kind)
+  SAMPLE BY user_id
+  TTL ts + INTERVAL 30 DAY DELETE
+  SETTINGS index_granularity = 8192, allow_nullable_key = 0
+  COMMENT 'events'`;
+  const node = parse(sql) as TableNode;
+
+  test("reads the statement's structure", () => {
+    expect(node.statement).toBe("table");
+    expect(node.ifNotExists).toBe(true);
+    expect(text(sql, node.name)).toBe("db.events");
+    expect(text(sql, node.onCluster)).toBe("main");
+    expect(node.columns.map((c) => c.name)).toEqual(["user_id", "kind", "ts", "tags", "n", "total"]);
+    expect(node.indexes.map((i) => i.name)).toEqual(["k"]);
+    expect(node.projections.map((p) => p.name)).toEqual(["by_kind"]);
+    expect(node.constraints.map((c) => [c.name, c.kind])).toEqual([["c", "CHECK"]]);
+  });
+
+  test("keeps each expression as its source text", () => {
+    const ts = node.columns[2]!;
+    expect(text(sql, ts.type)).toBe("DateTime64(3, 'UTC')");
+    expect(text(sql, ts.codec)).toBe("Delta, ZSTD(3)");
+    expect(text(sql, ts.ttl)).toBe("ts + INTERVAL 1 DAY");
+    expect(text(sql, node.columns[3]!.default!.expr)).toBe("['a', 'b']");
+    expect(node.columns[5]!.default!.kind).toBe("MATERIALIZED");
+    expect(node.engine!.name).toBe("ReplicatedReplacingMergeTree");
+    expect(node.engine!.args!.map((a) => text(sql, a))).toEqual(["'/t/{shard}'", "'{replica}'", "ts"]);
+    expect(text(sql, node.orderBy)).toBe("(user_id, kind)");
+    expect(text(sql, node.ttl)).toBe("ts + INTERVAL 30 DAY DELETE");
+    expect(node.settings!.map((s) => [s.key, text(sql, s.value)])).toEqual([
+      ["index_granularity", "8192"],
+      ["allow_nullable_key", "0"],
+    ]);
+    expect(text(sql, node.comment)).toBe("'events'");
+  });
+
+  test("a column named like a keyword is a column", () => {
+    const t = parse("CREATE TABLE t (index UInt8, projection String, constraint UInt8) ENGINE = Log") as TableNode;
+    expect(t.columns.map((c) => c.name)).toEqual(["index", "projection", "constraint"]);
+  });
+
+  test("the clauses may come in any order", () => {
+    const t = parse("CREATE TABLE t (a UInt8) ORDER BY a ENGINE = MergeTree PARTITION BY a") as TableNode;
+    expect(t.engine!.name).toBe("MergeTree");
+  });
+
+  test("CREATE TABLE ... AS is refused, since it declares no columns", () => {
+    expect(() => parse("CREATE TABLE t AS other")).toThrow(/column list/);
+  });
+});
+
+describe("parsing views and databases", () => {
+  test("a materialized view with a target, a column list and a refresh", () => {
+    const sql =
+      "CREATE MATERIALIZED VIEW mv REFRESH EVERY 1 HOUR APPEND TO dst (a UInt8, b) DEFINER = alice SQL SECURITY DEFINER AS SELECT a, b FROM src COMMENT 'x'";
+    const v = parse(sql) as ViewNode;
+    expect(v.materialized).toBe(true);
+    expect(text(sql, v.refresh)).toBe("EVERY 1 HOUR");
+    expect(v.append).toBe(true);
+    expect(text(sql, v.to)).toBe("dst");
+    expect(v.columns.map((c) => c.name)).toEqual(["a", "b"]);
+    expect(text(sql, v.security)).toBe("DEFINER = alice SQL SECURITY DEFINER");
+    expect(text(sql, v.select)).toBe("SELECT a, b FROM src");
+  });
+
+  test("a view the server printed back, with its UUID", () => {
+    const v = parse("CREATE VIEW default.v UUID '6a1b' (`x` UInt8) AS SELECT 1 AS x") as ViewNode;
+    expect(v.columns[0]!.name).toBe("x");
+  });
+
+  test("a database with an engine and a comment", () => {
+    const sql = "CREATE DATABASE IF NOT EXISTS analytics ENGINE = Replicated('/db', '{shard}', '{replica}') COMMENT 'a'";
+    const d = parseCreate(tokenizeText(sql, 0));
+    expect(d.statement).toBe("database");
+  });
+});
+
+describe("interpolations", () => {
+  test("stand where a name, a type, an engine or an expression goes", () => {
+    const parts = ["CREATE TABLE ", " (", " ", ", b UInt8 DEFAULT ", ") ENGINE = ", " ORDER BY ", ""];
+    const node = parseCreate(tokenize(parts)) as TableNode;
+    expect(node.name.refs).toEqual([0]);
+    expect(node.columns[0]!.nameSpan.refs).toEqual([1]);
+    expect(node.columns[0]!.type!.refs).toEqual([2]);
+    expect(node.columns[1]!.default!.expr!.refs).toEqual([3]);
+    expect(node.engine!.nameSpan.refs).toEqual([4]);
+    expect(node.orderBy!.refs).toEqual([5]);
+  });
+});
+
+describe("syntax errors", () => {
+  test("are located at the token, in the part it sits in", () => {
+    const parts = ["CREATE TABLE t (\n  a UInt8,\n  b Strin g\n) ENGINE = Log"];
+    try {
+      parseCreate(tokenize(parts));
+      expect.unreachable();
+    } catch (err) {
+      expect(err).toBeInstanceOf(SqlSyntaxError);
+      const e = err as SqlSyntaxError;
+      expect(parts[0]!.slice(e.offset, e.offset + 1)).toBe("g");
+    }
+  });
+
+  test("a truncated statement says so", () => {
+    expect(() => parse("CREATE TABLE t (a UInt8")).toThrow(/expected '\)'|unexpected end/);
+  });
+});
+
+describe("the ClickHouse test corpus", () => {
+  // 300 statements from ClickHouse's own SQL tests (see testdata/NOTICE). A
+  // statement the parser accepted when the fixture was cut must keep parsing.
+  const corpus = JSON.parse(readFileSync(join(import.meta.dirname, "testdata", "clickhouse-tests-corpus.json"), "utf-8")) as string[];
+
+  test("every statement parses", () => {
+    const failed: string[] = [];
+    for (const sql of corpus) {
+      try {
+        parse(sql);
+      } catch (err) {
+        failed.push(`${(err as Error).message}: ${sql.slice(0, 120)}`);
+      }
+    }
+    expect(failed).toEqual([]);
+    expect(corpus.length).toBe(300);
+  });
+});