@intentius/chant-lexicon-sql 0.124.48 → 0.124.50

package/dist/postgres/plan/statements.js

@@ -0,0 +1,364 @@
+/**
+ * The Postgres statement classifier (#4407): a migration file's statements,
+ * each given the class and rule the schema-diff classifier (`./rules.ts`)
+ * gives the same change, with the lock the rule's restriction names. It reads
+ * text and contacts no server.
+ *
+ * `CREATE`, `GRANT`, `REVOKE`, `COMMENT ON` and `ALTER TABLE ... ROW LEVEL
+ * SECURITY` go through the declaration parser (`../parser.ts`). The parser
+ * has no `ALTER` grammar, so the other `ALTER` and `DROP` statements are read
+ * word by word from the same tokens.
+ *
+ * A statement alone cannot decide some changes. `ALTER COLUMN ... TYPE` is a
+ * catalog change or a table rewrite by the column's old type, which the file
+ * does not state: it is `undecided`, naming SQLPG206 and SQLPG207 (and
+ * SQLPG208 with a `USING` expression). `CREATE OR REPLACE VIEW` is SQLPG250
+ * or SQLPG251 by whether the columns stay. A statement no rule covers is
+ * `unclassified` with a note.
+ */
+import { isTrivia, tokenizeText } from "../tokens.js";
+import { parseStatements } from "../parser.js";
+import { classifiedOf, lockOf, splitTopLevel, sqlHead } from "../../core/statement-class.js";
+import { PG_CHANGE_CLASSES, PG_CLASSIFIER_RULES } from "./rules.js";
+const classified = (id, extra = {}) => {
+    const lock = lockOf(PG_CLASSIFIER_RULES[id].restriction);
+    return classifiedOf(PG_CLASSIFIER_RULES, PG_CHANGE_CLASSES.label, id, { ...(lock ? { lock } : {}), ...extra });
+};
+const rule = (id, extra) => ({ rules: [{ id, ...(extra ? { extra } : {}) }] });
+const VOLATILE = /\b(?:clock_timestamp|random|gen_random_uuid|uuid_generate_v\d\w*|nextval|timeofday|txid_current|setseed)\s*\(/i;
+/** The words from `i` that are one possibly qualified name, and the index after it. */
+function nameAt(words, i) {
+    let name = words[i] ?? "";
+    let j = i + 1;
+    while (words[j] === "." && words[j + 1] !== undefined) {
+        name += `.${words[j + 1]}`;
+        j += 2;
+    }
+    return { name, next: j };
+}
+const bare = (name) => (name.split(".").pop() ?? name).replace(/^"|"$/g, "").toLowerCase();
+const has = (u, ...seq) => u.some((_, i) => seq.every((w, k) => u[i + k] === w));
+/** One `ALTER TABLE` action (the words between top-level commas). */
+function tableAction(a) {
+    const u = a.map((w) => w.toUpperCase());
+    const first = u[0];
+    if (first === "ADD") {
+        let i = 1;
+        if (u[i] === "COLUMN")
+            i++;
+        if (u[i] === "CONSTRAINT" || ["PRIMARY", "UNIQUE", "CHECK", "FOREIGN", "EXCLUDE"].includes(u[i] ?? "")) {
+            let k = i;
+            if (u[k] === "CONSTRAINT")
+                k += 2;
+            const kind = u[k];
+            const notValid = has(u, "NOT", "VALID");
+            if (kind === "NOT" && u[k + 1] === "NULL")
+                return rule("SQLPG210");
+            if (notValid)
+                return rule("SQLPG217", { note: `${kind ?? "constraint"} added NOT VALID; VALIDATE CONSTRAINT is SQLPG220` });
+            if (kind === "PRIMARY" || kind === "UNIQUE")
+                return rule("SQLPG221", has(u, "USING", "INDEX") ? { note: "from an existing unique index, so no build under this lock" } : {});
+            if (kind === "CHECK")
+                return rule("SQLPG218");
+            if (kind === "FOREIGN")
+                return rule("SQLPG219");
+            if (kind === "EXCLUDE")
+                return rule("SQLPG222");
+            return { none: "an ADD CONSTRAINT of a kind no rule names" };
+        }
+        if (u[i] === "IF" && u[i + 1] === "NOT" && u[i + 2] === "EXISTS")
+            i += 3;
+        const hasDefault = u.includes("DEFAULT");
+        const defaultText = hasDefault ? a.slice(u.indexOf("DEFAULT") + 1).join(" ") : "";
+        const generated = has(u, "GENERATED");
+        const stored = u.includes("STORED") && generated;
+        const identity = u.includes("IDENTITY");
+        const notNull = has(u, "NOT", "NULL");
+        if (stored || identity)
+            return rule("SQLPG202", { note: stored ? "a STORED generated column" : "an identity column" });
+        if (VOLATILE.test(defaultText))
+            return rule("SQLPG202", { note: "a volatile default" });
+        if (notNull && !hasDefault && !generated)
+            return rule("SQLPG203");
+        return rule("SQLPG201");
+    }
+    if (first === "DROP") {
+        if (u[1] === "CONSTRAINT")
+            return rule("SQLPG223");
+        return rule("SQLPG204", { destructive: true });
+    }
+    if (first === "RENAME") {
+        if (u[1] === "COLUMN" || (u[1] !== "CONSTRAINT" && u[1] !== "TO"))
+            return rule("SQLPG205");
+        return rule("SQLPG228");
+    }
+    if (first === "ALTER") {
+        let i = 1;
+        if (u[i] === "COLUMN")
+            i++;
+        if (u[i] === "CONSTRAINT")
+            return { none: "ALTER CONSTRAINT (deferrability)" };
+        const rest = u.slice(i + 1);
+        const col = a[i] ?? "column";
+        if (rest[0] === "TYPE" || (rest[0] === "SET" && rest[1] === "DATA" && rest[2] === "TYPE")) {
+            const using = rest.includes("USING");
+            return {
+                undecided: using ? ["SQLPG206", "SQLPG207", "SQLPG208"] : ["SQLPG206", "SQLPG207"],
+                note: `the new type of ${col} is a catalog change or a table rewrite by its old type${using ? ", or a change across kinds with this USING expression," : ""}, which the file does not state`,
+            };
+        }
+        if (rest[0] === "SET" && rest[1] === "DEFAULT")
+            return rule("SQLPG209");
+        if (rest[0] === "DROP" && rest[1] === "DEFAULT")
+            return rule("SQLPG209");
+        if (rest[0] === "SET" && rest[1] === "NOT" && rest[2] === "NULL")
+            return rule("SQLPG210");
+        if (rest[0] === "DROP" && rest[1] === "NOT" && rest[2] === "NULL")
+            return rule("SQLPG211");
+        if (rest[0] === "SET" && rest[1] === "EXPRESSION")
+            return rule("SQLPG212");
+        if ((rest[0] === "ADD" && rest[1] === "GENERATED") || (rest[0] === "SET" && (rest[1] === "GENERATED" || rest[1] === "INCREMENT" || rest[1] === "START" || rest[1] === "RESTART")) || rest[0] === "RESTART" || (rest[0] === "DROP" && rest[1] === "IDENTITY")) {
+            return rule("SQLPG213");
+        }
+        if (rest[0] === "SET" && (rest[1] === "STORAGE" || rest[1] === "COMPRESSION"))
+            return rule("SQLPG215");
+        return { none: `ALTER COLUMN ${rest.slice(0, 2).join(" ")}` };
+    }
+    if (first === "VALIDATE" && u[1] === "CONSTRAINT")
+        return rule("SQLPG220");
+    if (first === "SET" || first === "RESET") {
+        if (u[1] === "LOGGED" || u[1] === "UNLOGGED")
+            return rule("SQLPG225");
+        if (u[1] === "ACCESS" || u[1] === "TABLESPACE")
+            return rule("SQLPG226");
+        if (u[1] === "SCHEMA")
+            return rule("SQLPG228");
+        if (u[1] === "(" || first === "RESET")
+            return rule("SQLPG224");
+        return { none: `ALTER TABLE ${u.slice(0, 2).join(" ")}` };
+    }
+    if (first === "ATTACH" || first === "DETACH" || first === "INHERIT" || (first === "NO" && u[1] === "INHERIT") || first === "OF" || (first === "NOT" && u[1] === "OF"))
+        return rule("SQLPG227");
+    if ((first === "ENABLE" || first === "DISABLE" || first === "FORCE" || (first === "NO" && u[1] === "FORCE")) && has(u, "ROW", "LEVEL", "SECURITY"))
+        return rule("SQLPG293");
+    if ((first === "ENABLE" || first === "DISABLE") && (u[1] === "TRIGGER" || u[1] === "REPLICA" || u[1] === "ALWAYS"))
+        return rule("SQLPG284");
+    return { none: `ALTER TABLE ${u.slice(0, 2).join(" ")}` };
+}
+/** `ALTER <object> ...` other than `TABLE`, by its second word. */
+function alterOther(u, a) {
+    const obj = u[1];
+    const rename = u.includes("RENAME");
+    if (obj === "INDEX")
+        return rename ? rule("SQLPG229") : rule("SQLPG243");
+    if (obj === "TYPE") {
+        if (has(u, "ADD", "VALUE"))
+            return rule("SQLPG260");
+        if (has(u, "RENAME", "TO"))
+            return rule("SQLPG228");
+        return { none: "ALTER TYPE other than ADD VALUE and RENAME TO" };
+    }
+    if (obj === "SEQUENCE")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : has(u, "OWNER", "TO") ? { none: "ALTER SEQUENCE OWNER TO" } : rule("SQLPG265");
+    if (obj === "VIEW")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : has(u, "OWNER", "TO") ? { none: "ALTER VIEW OWNER TO" } : rule("SQLPG253");
+    if (obj === "MATERIALIZED")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : { none: "ALTER MATERIALIZED VIEW other than RENAME" };
+    if (obj === "SCHEMA")
+        return rename ? rule("SQLPG228") : has(u, "OWNER", "TO") ? rule("SQLPG267") : { none: "ALTER SCHEMA" };
+    if (obj === "EXTENSION")
+        return has(u, "UPDATE") || has(u, "SET", "SCHEMA") ? rule("SQLPG266") : { none: "ALTER EXTENSION ADD or DROP member" };
+    if (obj === "FUNCTION" || obj === "PROCEDURE" || obj === "ROUTINE")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : { none: `ALTER ${obj} other than RENAME` };
+    if (obj === "TRIGGER")
+        return rule("SQLPG284");
+    if (obj === "POLICY")
+        return rename ? rule("SQLPG228") : rule("SQLPG291");
+    if (obj === "ROLE" || obj === "USER" || obj === "GROUP")
+        return rule("SQLPG294");
+    if (obj === "DOMAIN") {
+        if (rename || has(u, "SET", "SCHEMA"))
+            return rule("SQLPG228");
+        if (has(u, "ADD", "CONSTRAINT") || (u[3] === "ADD" && ["CHECK", "NOT"].includes(u[4] ?? "")))
+            return rule("SQLPG262");
+        if (has(u, "OWNER", "TO"))
+            return { none: "ALTER DOMAIN OWNER TO" };
+        return rule("SQLPG263");
+    }
+    if (obj === "SERVER" || obj === "PUBLICATION" || (obj === "FOREIGN" && u[2] === "DATA"))
+        return rename ? rule("SQLPG228") : rule("SQLPG303");
+    void a;
+    return { none: `ALTER ${obj ?? ""}`.trim() };
+}
+function dropStatement(u) {
+    const obj = u[1] === "MATERIALIZED" || u[1] === "FOREIGN" || u[1] === "EVENT" ? `${u[1]} ${u[2]}` : u[1];
+    if (obj === "INDEX")
+        return rule("SQLPG242", u[2] === "CONCURRENTLY" ? { note: "DROP INDEX CONCURRENTLY waits for running queries instead of blocking them" } : {});
+    if (obj === "TRIGGER")
+        return rule("SQLPG285", { destructive: false });
+    if (obj === "POLICY")
+        return rule("SQLPG292", { destructive: false });
+    return rule("SQLPG270", { destructive: true });
+}
+/** How a `CREATE` that the parser could not read starts: its kind by key words. */
+function createByWords(u) {
+    let i = 1;
+    const orReplace = u[i] === "OR" && u[i + 1] === "REPLACE";
+    if (orReplace)
+        i += 2;
+    while (["GLOBAL", "LOCAL", "TEMPORARY", "TEMP", "UNLOGGED", "RECURSIVE", "UNIQUE", "CONSTRAINT"].includes(u[i] ?? "") && u[i + 1] !== "INDEX" && u[i] !== "UNIQUE")
+        i++;
+    if (u[i] === "UNIQUE")
+        i++;
+    if (u[i] === "INDEX") {
+        const concurrently = u[i + 1] === "CONCURRENTLY";
+        return concurrently ? rule("SQLPG240") : rule("SQLPG241");
+    }
+    if (orReplace && (u[i] === "FUNCTION" || u[i] === "PROCEDURE"))
+        return rule("SQLPG280");
+    if (orReplace && u[i] === "VIEW")
+        return { undecided: ["SQLPG250", "SQLPG251"], note: "whether the view keeps its columns depends on the view it replaces" };
+    if (orReplace && u[i] === "AGGREGATE")
+        return rule("SQLPG302");
+    if (u[i] === "TRIGGER")
+        return rule("SQLPG283");
+    if (u[i] === "POLICY")
+        return rule("SQLPG290");
+    return rule("SQLPG200");
+}
+/** A statement the parser read: its rule, given the tables this file created earlier. */
+function fromNode(n, created) {
+    switch (n.statement) {
+        case "table":
+            created.add(bare(n.name.pieces.join(".")));
+            return rule("SQLPG200");
+        case "index":
+            if (n.concurrently)
+                return rule("SQLPG240");
+            if (created.has(bare(n.table.pieces.join("."))))
+                return rule("SQLPG200", { note: "an index on a table this file creates, which has no rows to block" });
+            return rule("SQLPG241");
+        case "view":
+            if (n.orReplace && !n.materialized)
+                return { undecided: ["SQLPG250", "SQLPG251"], note: "whether the view keeps its columns depends on the view it replaces" };
+            return rule("SQLPG200");
+        case "function":
+        case "procedure":
+            return n.orReplace ? rule("SQLPG280") : rule("SQLPG200");
+        case "aggregate":
+            return n.orReplace ? rule("SQLPG302") : rule("SQLPG200");
+        case "trigger":
+            return created.has(bare(n.table.pieces.join("."))) ? rule("SQLPG200", { note: "a trigger on a table this file creates" }) : rule("SQLPG283");
+        case "policy":
+            return created.has(bare(n.table.pieces.join("."))) ? rule("SQLPG200", { note: "a policy on a table this file creates" }) : rule("SQLPG290");
+        case "grant":
+            return n.defaults ? rule("SQLPG298") : n.revoke ? rule("SQLPG297") : rule("SQLPG296");
+        case "rowSecurity":
+            return rule("SQLPG293");
+        case "comment":
+            return rule("SQLPG216");
+        case "role":
+            return rule("SQLPG200");
+        default:
+            return rule("SQLPG200");
+    }
+}
+const DATA_WORDS = new Set(["INSERT", "UPDATE", "DELETE", "SELECT", "WITH", "COPY", "CALL", "DO", "SET", "BEGIN", "START", "COMMIT", "END", "ROLLBACK", "SAVEPOINT", "RELEASE", "ANALYZE", "ANALYSE", "VACUUM", "REINDEX", "LOCK", "NOTIFY", "LISTEN", "RESET", "SHOW", "EXPLAIN", "VALUES", "MERGE", "REFRESH", "CLUSTER", "CHECKPOINT", "DISCARD", "PREPARE", "EXECUTE", "DEALLOCATE"]);
+/** Classify one statement. `created` is the tables the file's earlier statements created. */
+function read(sql, created) {
+    let tokens;
+    try {
+        tokens = tokenizeText(sql, 0);
+    }
+    catch {
+        return [{ none: "text the tokenizer could not read" }];
+    }
+    const words = tokens.filter((t) => !isTrivia(t) && t.text !== ";").map((t) => t.text);
+    const u = words.map((w) => w.toUpperCase());
+    const head = u[0];
+    if (head === undefined)
+        return [{ data: "an empty statement" }];
+    if (head === "CREATE" || head === "GRANT" || head === "REVOKE" || head === "COMMENT" || (head === "ALTER" && (u[1] === "DEFAULT" || (u[1] === "TABLE" && has(u, "ROW", "LEVEL", "SECURITY"))))) {
+        try {
+            const nodes = parseStatements(tokens);
+            return nodes.map((n) => fromNode(n, created));
+        }
+        catch {
+            if (head === "CREATE")
+                return [createByWords(u)];
+            if (head === "GRANT")
+                return [rule("SQLPG296")];
+            if (head === "REVOKE")
+                return [rule("SQLPG297")];
+            if (head === "COMMENT")
+                return [rule("SQLPG216")];
+            if (head === "ALTER" && u[1] === "DEFAULT")
+                return [rule("SQLPG298")];
+            return [rule("SQLPG293")];
+        }
+    }
+    if (head === "ALTER" && u[1] === "TABLE") {
+        let i = 2;
+        if (u[i] === "IF" && u[i + 1] === "EXISTS")
+            i += 2;
+        if (u[i] === "ONLY")
+            i++;
+        const { name, next } = nameAt(words, i);
+        if (u[next] === "*")
+            i = next + 1;
+        else
+            i = next;
+        const actions = splitTopLevel(words.slice(i));
+        if (actions.length === 0)
+            return [{ none: `ALTER TABLE ${name} with no action` }];
+        void name;
+        return actions.map(tableAction);
+    }
+    if (head === "ALTER")
+        return [alterOther(u, words)];
+    if (head === "DROP")
+        return [dropStatement(u)];
+    if (head === "TRUNCATE")
+        return [{ data: "TRUNCATE removes every row of the table" }];
+    if (DATA_WORDS.has(head))
+        return [{ data: `${head} reads or writes rows or the session, not the schema` }];
+    return [{ none: `${head} is not a statement the classifier reads` }];
+}
+/**
+ * Classify a migration's up statements, in order. The statements are the
+ * file's own text, one per entry (a Flyway file after placeholder
+ * substitution).
+ */
+export function classifyPgStatements(statements) {
+    const created = new Set();
+    return statements.map((sql, k) => {
+        const readings = read(sql, created);
+        const out = { index: k + 1, sql: sqlHead(sql), outcome: "classified", changes: [] };
+        const none = [];
+        for (const r of readings) {
+            if ("rules" in r)
+                out.changes.push(...r.rules.map((x) => classified(x.id, x.extra)));
+            else if ("undecided" in r) {
+                out.candidates = r.undecided.map((id) => classified(id));
+                out.note = r.note;
+            }
+            else if ("none" in r)
+                none.push(r.none);
+            else
+                out.note = r.data;
+        }
+        if (out.candidates && out.changes.length === 0)
+            out.outcome = "undecided";
+        else if (out.candidates) {
+            // A statement with some decided clauses and one undecided: report undecided, and keep the decided ones.
+            out.outcome = "undecided";
+        }
+        else if (out.changes.length === 0 && none.length === 0)
+            out.outcome = "data";
+        else if (none.length > 0) {
+            out.outcome = out.changes.length > 0 ? "classified" : "unclassified";
+            out.note = [out.note, `no rule covers ${none.join("; ")}`].filter(Boolean).join("; ");
+        }
+        return out;
+    });
+}

package/dist/postgres/testing/roundtrip-schema.d.ts

@@ -6,9 +6,10 @@
  * domain over its type, a collation, composite and range types (and a
  * multirange column), plain and ordered-set aggregates, a cast and an event
  * trigger, an operator, extended statistics, a foreign data wrapper and server, and a
- * publication (#3911), a partitioned table and a partition, an ORM's
+ * publication (#3911), a foreign table, an operator class and family, a text
+ * search dictionary and configuration (#4406), a partitioned table and a partition, an ORM's
  * revision table that import leaves out, and an object carrying chant's
  * ownership trailer.
  */
-export declare const ROUNDTRIP_SCHEMA = "\nCREATE SCHEMA app;\nCOMMENT ON SCHEMA app IS 'The shop';\nCREATE EXTENSION citext WITH SCHEMA app;\nCREATE TYPE app.order_status AS ENUM ('placed', 'paid', 'shipped');\nCREATE DOMAIN app.email AS app.citext CONSTRAINT email_shape CHECK (VALUE LIKE '%@%');\nCOMMENT ON CONSTRAINT email_shape ON DOMAIN app.email IS 'needs an @';\nCREATE SEQUENCE app.invoice_seq AS integer START WITH 1000 CACHE 10;\nCREATE TABLE app.users (\n  id bigint GENERATED ALWAYS AS IDENTITY (START WITH 10) PRIMARY KEY,\n  email app.email NOT NULL UNIQUE,\n  plan text NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'pro')),\n  created_at timestamptz NOT NULL DEFAULT now()\n) WITH (fillfactor = 90);\nCOMMENT ON TABLE app.users IS 'Accounts [chant managed-by=chant stack=shop env=e2e]';\nCOMMENT ON COLUMN app.users.email IS 'Login name';\nCREATE TABLE app.orders (\n  id serial PRIMARY KEY,\n  user_id bigint NOT NULL REFERENCES app.users (id) ON DELETE CASCADE,\n  invoice_no integer NOT NULL DEFAULT nextval('app.invoice_seq'),\n  status app.order_status NOT NULL DEFAULT 'placed',\n  amount numeric(12, 2) NOT NULL CONSTRAINT amount_positive CHECK (amount >= 0),\n  discount int DEFAULT -1,\n  total numeric GENERATED ALWAYS AS (amount * 2) STORED,\n  placed_at timestamp(3) without time zone\n);\nCREATE INDEX orders_user_idx ON app.orders (user_id, placed_at DESC) WHERE status <> 'shipped';\nCREATE UNIQUE INDEX orders_invoice_idx ON app.orders USING btree (invoice_no) INCLUDE (amount);\nCREATE TABLE app.measures (ts date NOT NULL, v double precision) PARTITION BY RANGE (ts);\nCREATE TABLE app.measures_2026 PARTITION OF app.measures FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');\nCREATE VIEW app.order_totals AS\n  SELECT u.id AS user_id, u.email, count(o.id) AS n, coalesce(sum(o.amount), 0) AS total\n  FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id\n  GROUP BY u.id, u.email;\nCREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;\nCREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);\nCOMMENT ON COLLATION app.ci IS 'Case-insensitive';\nCREATE TYPE app.pair AS (a integer, b text COLLATE \"C\");\nCOMMENT ON TYPE app.pair IS 'Two values';\nCREATE TYPE app.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi);\nCREATE TABLE app.people (id integer PRIMARY KEY, nick text COLLATE app.ci, span app.floatrange, tags app.floatmultirange);\nCREATE FUNCTION app.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;\nCREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0', PARALLEL = SAFE);\nCOMMENT ON AGGREGATE app.total(integer) IS 'A sum';\nCREATE FUNCTION app.middle(v double precision[]) RETURNS double precision LANGUAGE sql IMMUTABLE AS $$ SELECT v[(array_length(v, 1) + 1) / 2] $$;\nCREATE AGGREGATE app.median_of(ORDER BY double precision) (SFUNC = pg_catalog.array_append, STYPE = double precision[], FINALFUNC = app.middle);\nCREATE FUNCTION app.pair_text(p app.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$;\nCREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNMENT;\nCOMMENT ON CAST (app.pair AS text) IS 'a:b';\nCREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;\nCREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();\nCREATE FUNCTION app.int_same(a integer, b integer) RETURNS boolean LANGUAGE sql IMMUTABLE AS $$ SELECT a = b $$;\nCREATE OPERATOR app.=== (FUNCTION = app.int_same, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = OPERATOR(app.===), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES, MERGES);\nCOMMENT ON OPERATOR app.===(integer, integer) IS 'Same value';\nCREATE STATISTICS app.orders_stats (dependencies) ON user_id, status FROM app.orders;\nCOMMENT ON STATISTICS app.orders_stats IS 'Users and their order states';\nCREATE FOREIGN DATA WRAPPER app_fdw OPTIONS (debug 'true');\nCOMMENT ON FOREIGN DATA WRAPPER app_fdw IS 'Remote tables';\nCREATE SERVER app_replica TYPE 'pg' VERSION '16' FOREIGN DATA WRAPPER app_fdw OPTIONS (host 'db.internal', port '5432');\nCOMMENT ON SERVER app_replica IS 'The read replica';\nCREATE PUBLICATION app_pub FOR TABLE app.orders, app.users WITH (publish = 'insert, update');\nCOMMENT ON PUBLICATION app_pub IS 'Order changes';\nCREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);\n";
+export declare const ROUNDTRIP_SCHEMA = "\nCREATE SCHEMA app;\nCOMMENT ON SCHEMA app IS 'The shop';\nCREATE EXTENSION citext WITH SCHEMA app;\nCREATE TYPE app.order_status AS ENUM ('placed', 'paid', 'shipped');\nCREATE DOMAIN app.email AS app.citext CONSTRAINT email_shape CHECK (VALUE LIKE '%@%');\nCOMMENT ON CONSTRAINT email_shape ON DOMAIN app.email IS 'needs an @';\nCREATE SEQUENCE app.invoice_seq AS integer START WITH 1000 CACHE 10;\nCREATE TABLE app.users (\n  id bigint GENERATED ALWAYS AS IDENTITY (START WITH 10) PRIMARY KEY,\n  email app.email NOT NULL UNIQUE,\n  plan text NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'pro')),\n  created_at timestamptz NOT NULL DEFAULT now()\n) WITH (fillfactor = 90);\nCOMMENT ON TABLE app.users IS 'Accounts [chant managed-by=chant stack=shop env=e2e]';\nCOMMENT ON COLUMN app.users.email IS 'Login name';\nCREATE TABLE app.orders (\n  id serial PRIMARY KEY,\n  user_id bigint NOT NULL REFERENCES app.users (id) ON DELETE CASCADE,\n  invoice_no integer NOT NULL DEFAULT nextval('app.invoice_seq'),\n  status app.order_status NOT NULL DEFAULT 'placed',\n  amount numeric(12, 2) NOT NULL CONSTRAINT amount_positive CHECK (amount >= 0),\n  discount int DEFAULT -1,\n  total numeric GENERATED ALWAYS AS (amount * 2) STORED,\n  placed_at timestamp(3) without time zone\n);\nCREATE INDEX orders_user_idx ON app.orders (user_id, placed_at DESC) WHERE status <> 'shipped';\nCREATE UNIQUE INDEX orders_invoice_idx ON app.orders USING btree (invoice_no) INCLUDE (amount);\nCREATE TABLE app.measures (ts date NOT NULL, v double precision) PARTITION BY RANGE (ts);\nCREATE TABLE app.measures_2026 PARTITION OF app.measures FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');\nCREATE VIEW app.order_totals AS\n  SELECT u.id AS user_id, u.email, count(o.id) AS n, coalesce(sum(o.amount), 0) AS total\n  FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id\n  GROUP BY u.id, u.email;\nCREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;\nCREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);\nCOMMENT ON COLLATION app.ci IS 'Case-insensitive';\nCREATE TYPE app.pair AS (a integer, b text COLLATE \"C\");\nCOMMENT ON TYPE app.pair IS 'Two values';\nCREATE TYPE app.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi);\nCREATE TABLE app.people (id integer PRIMARY KEY, nick text COLLATE app.ci, span app.floatrange, tags app.floatmultirange);\nCREATE FUNCTION app.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;\nCREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0', PARALLEL = SAFE);\nCOMMENT ON AGGREGATE app.total(integer) IS 'A sum';\nCREATE FUNCTION app.middle(v double precision[]) RETURNS double precision LANGUAGE sql IMMUTABLE AS $$ SELECT v[(array_length(v, 1) + 1) / 2] $$;\nCREATE AGGREGATE app.median_of(ORDER BY double precision) (SFUNC = pg_catalog.array_append, STYPE = double precision[], FINALFUNC = app.middle);\nCREATE FUNCTION app.pair_text(p app.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$;\nCREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNMENT;\nCOMMENT ON CAST (app.pair AS text) IS 'a:b';\nCREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;\nCREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();\nCREATE FUNCTION app.int_same(a integer, b integer) RETURNS boolean LANGUAGE sql IMMUTABLE AS $$ SELECT a = b $$;\nCREATE OPERATOR app.=== (FUNCTION = app.int_same, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = OPERATOR(app.===), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES, MERGES);\nCOMMENT ON OPERATOR app.===(integer, integer) IS 'Same value';\nCREATE STATISTICS app.orders_stats (dependencies) ON user_id, status FROM app.orders;\nCOMMENT ON STATISTICS app.orders_stats IS 'Users and their order states';\nCREATE FOREIGN DATA WRAPPER app_fdw OPTIONS (debug 'true');\nCOMMENT ON FOREIGN DATA WRAPPER app_fdw IS 'Remote tables';\nCREATE SERVER app_replica TYPE 'pg' VERSION '16' FOREIGN DATA WRAPPER app_fdw OPTIONS (host 'db.internal', port '5432');\nCOMMENT ON SERVER app_replica IS 'The read replica';\nCREATE PUBLICATION app_pub FOR TABLE app.orders, app.users WITH (publish = 'insert, update');\nCOMMENT ON PUBLICATION app_pub IS 'Order changes';\nCREATE FOREIGN TABLE app.remote_orders (id integer OPTIONS (column_name 'order_id') NOT NULL, status text DEFAULT 'placed', CONSTRAINT status_known CHECK (status IS NOT NULL)) SERVER app_replica OPTIONS (table_name 'orders');\nCOMMENT ON FOREIGN TABLE app.remote_orders IS 'Orders on the replica';\nCREATE OPERATOR CLASS app.int_hash_ops FOR TYPE integer USING hash AS OPERATOR 1 =, FUNCTION 1 hashint4(integer);\nCOMMENT ON OPERATOR CLASS app.int_hash_ops USING hash IS 'Hash by value';\nCREATE OPERATOR FAMILY app.spare_ops USING btree;\nCREATE TEXT SEARCH DICTIONARY app.shop_stop (TEMPLATE = simple, StopWords = english);\nCREATE TEXT SEARCH CONFIGURATION app.shop (PARSER = pg_catalog.\"default\");\nALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR asciiword, word WITH app.shop_stop, english_stem;\nALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR int, uint WITH simple;\nCOMMENT ON TEXT SEARCH CONFIGURATION app.shop IS 'Shop search';\nCREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);\n";
 //# sourceMappingURL=roundtrip-schema.d.ts.map

package/dist/postgres/testing/roundtrip-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,27IA+D5B,CAAC"}
+{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,03KAyE5B,CAAC"}

package/dist/postgres/testing/roundtrip-schema.js

@@ -6,7 +6,8 @@
  * domain over its type, a collation, composite and range types (and a
  * multirange column), plain and ordered-set aggregates, a cast and an event
  * trigger, an operator, extended statistics, a foreign data wrapper and server, and a
- * publication (#3911), a partitioned table and a partition, an ORM's
+ * publication (#3911), a foreign table, an operator class and family, a text
+ * search dictionary and configuration (#4406), a partitioned table and a partition, an ORM's
  * revision table that import leaves out, and an object carrying chant's
  * ownership trailer.
  */
@@ -72,5 +73,15 @@ CREATE SERVER app_replica TYPE 'pg' VERSION '16' FOREIGN DATA WRAPPER app_fdw OP
 COMMENT ON SERVER app_replica IS 'The read replica';
 CREATE PUBLICATION app_pub FOR TABLE app.orders, app.users WITH (publish = 'insert, update');
 COMMENT ON PUBLICATION app_pub IS 'Order changes';
+CREATE FOREIGN TABLE app.remote_orders (id integer OPTIONS (column_name 'order_id') NOT NULL, status text DEFAULT 'placed', CONSTRAINT status_known CHECK (status IS NOT NULL)) SERVER app_replica OPTIONS (table_name 'orders');
+COMMENT ON FOREIGN TABLE app.remote_orders IS 'Orders on the replica';
+CREATE OPERATOR CLASS app.int_hash_ops FOR TYPE integer USING hash AS OPERATOR 1 =, FUNCTION 1 hashint4(integer);
+COMMENT ON OPERATOR CLASS app.int_hash_ops USING hash IS 'Hash by value';
+CREATE OPERATOR FAMILY app.spare_ops USING btree;
+CREATE TEXT SEARCH DICTIONARY app.shop_stop (TEMPLATE = simple, StopWords = english);
+CREATE TEXT SEARCH CONFIGURATION app.shop (PARSER = pg_catalog."default");
+ALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR asciiword, word WITH app.shop_stop, english_stem;
+ALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR int, uint WITH simple;
+COMMENT ON TEXT SEARCH CONFIGURATION app.shop IS 'Shop search';
 CREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);
 `;

package/dist/postgres.d.ts

@@ -5,7 +5,7 @@
  * the statements are Postgres's own DDL, parsed at build time into entities,
  * and the names fold and quote as Postgres folds and quotes them.
  */
-export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, type PostgresEntityType, type PostgresSchema, type PostgresRelation, type PostgresTable, type PostgresView, type PostgresIndex, type PostgresSequence, type PostgresEnum, type PostgresCompositeType, type PostgresRangeType, type PostgresType, type PostgresDomain, type PostgresAggregate, type PostgresCollation, type PostgresCast, type PostgresEventTrigger, type PostgresOperator, type PostgresStatistics, type PostgresForeignDataWrapper, type PostgresForeignServer, type PostgresPublication, type PostgresExtension, type PostgresFunction, type PostgresProcedure, type PostgresTrigger, type PostgresPolicy, type PostgresRole, type PostgresGrant, type ColumnDef, type KeyDef, type CheckDef, type ForeignKeyDef, type ExclusionDef, type SchemaProps, type TableProps, type IndexProps, type ViewProps, type SequenceProps, type EnumProps, type CompositeTypeProps, type CompositeAttributeDef, type RangeTypeProps, type AggregateProps, type AggregateArgDef, type CollationProps, type CastProps, type EventTriggerProps, type OperatorProps, type StatisticsProps, type ForeignDataWrapperProps, type ForeignServerProps, type PublicationProps, type PublicationTableDef, type DomainProps, type ExtensionProps, type RoutineProps, type RoutineArgDef, type FunctionProps, type ProcedureProps, type TriggerProps, type PolicyProps, type RoleProps, type GrantProps, type DefaultPrivilegesProps, type PrivilegeDef, type LineageEdge, type SqlSchema, type RowOf, type Column, type ColumnTraits, type AnyColumn, type UncheckedColumn, type KeyColumn, type NotNullColumn, type Named, type Unnamed, } from "./postgres/entities.js";
+export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, operatorClass, operatorFamily, foreignTable, textSearchConfiguration, textSearchDictionary, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, type PostgresEntityType, type PostgresSchema, type PostgresRelation, type PostgresTable, type PostgresView, type PostgresIndex, type PostgresSequence, type PostgresEnum, type PostgresCompositeType, type PostgresRangeType, type PostgresType, type PostgresDomain, type PostgresAggregate, type PostgresCollation, type PostgresCast, type PostgresEventTrigger, type PostgresOperator, type PostgresOperatorClass, type PostgresOperatorFamily, type PostgresForeignTable, type PostgresTextSearchConfiguration, type PostgresTextSearchDictionary, type PostgresStatistics, type PostgresForeignDataWrapper, type PostgresForeignServer, type PostgresPublication, type PostgresExtension, type PostgresFunction, type PostgresProcedure, type PostgresTrigger, type PostgresPolicy, type PostgresRole, type PostgresGrant, type ColumnDef, type KeyDef, type CheckDef, type ForeignKeyDef, type ExclusionDef, type SchemaProps, type TableProps, type IndexProps, type ViewProps, type SequenceProps, type EnumProps, type CompositeTypeProps, type CompositeAttributeDef, type RangeTypeProps, type AggregateProps, type AggregateArgDef, type CollationProps, type CastProps, type EventTriggerProps, type OperatorProps, type OperatorClassProps, type OperatorClassItemDef, type OperatorFamilyProps, type ForeignTableProps, type TextSearchConfigurationProps, type TextSearchDictionaryProps, type TextSearchMappingDef, type StatisticsProps, type ForeignDataWrapperProps, type ForeignServerProps, type PublicationProps, type PublicationTableDef, type DomainProps, type ExtensionProps, type RoutineProps, type RoutineArgDef, type FunctionProps, type ProcedureProps, type TriggerProps, type PolicyProps, type RoleProps, type GrantProps, type DefaultPrivilegesProps, type PrivilegeDef, type LineageEdge, type SqlSchema, type RowOf, type Column, type ColumnTraits, type AnyColumn, type UncheckedColumn, type KeyColumn, type NotNullColumn, type Named, type Unnamed, } from "./postgres/entities.js";
 export { POSTGRES_PROVIDERS, COMMON_REFUSED, providerData, isPostgresProvider, providerAllowsExtension, isProviderOwned, refusedStatement, normalizeStatement, type PostgresProvider, type ProviderData, type ProviderSource, type RefusedStatement, type LiveObjectRef, } from "./postgres/providers/index.js";
 export { PostgresMigrationOp, type PostgresMigrationOpConfig, type PostgresMigrationOpResources, type PostgresMigrationArgs, } from "./postgres/migrate/op.js";
 export { POSTGRES_RECEIPTS_TABLE } from "./postgres/migrate/receipts.js";

package/dist/postgres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"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"}

package/dist/postgres.js

@@ -5,7 +5,7 @@
  * the statements are Postgres's own DDL, parsed at build time into entities,
  * and the names fold and quote as Postgres folds and quotes them.
  */
-export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, } from "./postgres/entities.js";
+export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, operatorClass, operatorFamily, foreignTable, textSearchConfiguration, textSearchDictionary, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, } from "./postgres/entities.js";
 export { POSTGRES_PROVIDERS, COMMON_REFUSED, providerData, isPostgresProvider, providerAllowsExtension, isProviderOwned, refusedStatement, normalizeStatement, } from "./postgres/providers/index.js";
 export { PostgresMigrationOp, } from "./postgres/migrate/op.js";
 export { POSTGRES_RECEIPTS_TABLE } from "./postgres/migrate/receipts.js";

package/dist/rules/postgres-names.ts

@@ -474,6 +474,8 @@ export type OpClassResolution = { ok: true } | { ok: false; miss: Miss; otherMet
 /** An operator class for `method` at the target major. */
 export function resolveOpClass(p: PgProject, method: string, opclass: { schema?: string; name: string }): OpClassResolution {
   if (opclass.schema !== undefined && outsideProject(p, opclass.schema)) return { ok: true };
+  // A class the project declares (an `operatorClass` tag), for this method.
+  if (p.objects.some((o) => o.type === "Postgres::OperatorClass" && o.name === opclass.name && o.method === method && (opclass.schema === undefined || o.schema === opclass.schema))) return { ok: true };
   const classes = OPERATOR_CLASSES as Readonly<Record<string, Readonly<Record<string, Presence>>>>;
   if (presentAt(classes[method]?.[opclass.name], p.major)) return { ok: true };
   const ext = extensionFor(p, (e) => e.opclasses?.[method]?.includes(opclass.name) ?? false);

package/dist/rules/postgres-templates.ts

@@ -17,12 +17,12 @@ export const POSTGRES_TEMPLATE_SOURCES: readonly TemplateSource<PostgresTag>[] =
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql/postgres"],
-    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
+    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "operatorClass", "operatorFamily", "foreignTable", "textSearchConfiguration", "textSearchDictionary", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
   },
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql"],
-    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
+    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "operatorClass", "operatorFamily", "foreignTable", "textSearchConfiguration", "textSearchDictionary", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
   },
 ];
 

package/dist/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAgD,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAMtH,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAuFvF,wBAAsB,QAAQ,CAAC,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAoEpF"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,EAAgD,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAMtH,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AA4FvF,wBAAsB,QAAQ,CAAC,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAoEpF"}

package/dist/validate.js

@@ -44,6 +44,11 @@ const REQUIRED_ENTITIES = [
     "PostgresCast",
     "PostgresEventTrigger",
     "PostgresOperator",
+    "PostgresOperatorClass",
+    "PostgresOperatorFamily",
+    "PostgresForeignTable",
+    "PostgresTextSearchConfiguration",
+    "PostgresTextSearchDictionary",
     "PostgresStatistics",
     "PostgresForeignDataWrapper",
     "PostgresForeignServer",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-sql",
-  "version": "0.124.48",
+  "version": "0.124.50",
   "description": "SQL lexicon for chant — database schema as typed declarations, one dialect at a time; ClickHouse first, with types read from a pinned server's catalog",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -72,6 +72,6 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.124.48"
+    "@intentius/chant": "^0.124.50"
   }
 }

package/src/clickhouse/plan/statements.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "vitest";
+import { classifyClickHouseStatements } from "./statements";
+
+const one = (sql: string) => classifyClickHouseStatements([sql])[0]!;
+const rules = (sql: string) => one(sql).changes.map((c) => c.rule);
+
+describe("ClickHouse statements", () => {
+  test("a sort-key change is SQLCH220, a rebuild", () => {
+    const v = one("ALTER TABLE events MODIFY ORDER BY (user_id, ts)");
+    expect(v.outcome).toBe("classified");
+    expect(v.changes).toMatchObject([{ rule: "SQLCH220", class: "rebuild", label: "REBUILD" }]);
+  });
+
+  test("appending the column the same ALTER adds is undecided between SQLCH216 and SQLCH220", () => {
+    const v = one("ALTER TABLE events ADD COLUMN region String, MODIFY ORDER BY (user_id, region)");
+    expect(v.outcome).toBe("undecided");
+    expect(v.candidates!.map((c) => c.rule)).toEqual(["SQLCH216", "SQLCH220"]);
+    expect(v.changes.map((c) => c.rule)).toEqual(["SQLCH201"]);
+  });
+
+  test("a table created in the same file decides the key questions", () => {
+    const create = "CREATE TABLE events (user_id UInt64, ts DateTime, region String) ENGINE = MergeTree ORDER BY (user_id, ts)";
+    const [, appended] = classifyClickHouseStatements([create, "ALTER TABLE events ADD COLUMN extra String, MODIFY ORDER BY (user_id, ts, extra)"]);
+    expect(appended!.outcome).toBe("classified");
+    expect(appended!.changes.map((c) => c.rule)).toEqual(["SQLCH201", "SQLCH216"]);
+    expect(classifyClickHouseStatements([create, "ALTER TABLE events MODIFY COLUMN user_id UInt32"])[1]!.changes[0]!.rule).toBe("SQLCH211");
+    expect(classifyClickHouseStatements([create, "ALTER TABLE events MODIFY COLUMN region LowCardinality(String)"])[1]!.changes[0]!.rule).toBe("SQLCH210");
+  });
+
+  test("a column type change on a table the file does not create is undecided", () => {
+    const v = one("ALTER TABLE events MODIFY COLUMN user_id UInt32");
+    expect(v.outcome).toBe("undecided");
+    expect(v.candidates!.map((c) => c.rule)).toEqual(["SQLCH210", "SQLCH211"]);
+    expect(one("ALTER TABLE events DROP COLUMN a").candidates!.map((c) => c.rule)).toEqual(["SQLCH202", "SQLCH213"]);
+    expect(one("ALTER TABLE events RENAME COLUMN a TO b").candidates!.map((c) => c.rule)).toEqual(["SQLCH212", "SQLCH213"]);
+  });
+
+  test("metadata and rewrite changes", () => {
+    expect(rules("ALTER TABLE events ADD COLUMN IF NOT EXISTS a String DEFAULT ''")).toEqual(["SQLCH201"]);
+    expect(rules("ALTER TABLE events ON CLUSTER c MODIFY COLUMN a DEFAULT 'x'")).toEqual(["SQLCH207"]);
+    expect(rules("ALTER TABLE events MODIFY TTL ts + INTERVAL 30 DAY")).toEqual(["SQLCH205"]);
+    expect(rules("ALTER TABLE events ADD INDEX i a TYPE minmax GRANULARITY 1")).toEqual(["SQLCH204"]);
+    expect(rules("ALTER TABLE events MODIFY SETTING ttl_only_drop_parts = 1")).toEqual(["SQLCH206"]);
+    expect(rules("ALTER TABLE events MODIFY COMMENT 'x'")).toEqual(["SQLCH203"]);
+  });
+
+  test("create, drop, rename", () => {
+    expect(rules("CREATE TABLE t (a UInt8) ENGINE = MergeTree ORDER BY a")).toEqual(["SQLCH200"]);
+    expect(rules("CREATE MATERIALIZED VIEW mv TO t AS SELECT a FROM s")).toEqual(["SQLCH200"]);
+    expect(rules("CREATE USER u IDENTIFIED WITH no_password")).toEqual(["SQLCH200"]);
+    expect(one("DROP TABLE t").changes[0]).toMatchObject({ rule: "SQLCH250", destructive: true });
+    expect(rules("RENAME TABLE a TO b")).toEqual(["SQLCH230"]);
+    expect(rules("GRANT SELECT ON db.* TO r")).toEqual(["SQLCH273"]);
+  });
+
+  test("mutations are data; partition operations have no rule", () => {
+    expect(one("ALTER TABLE t UPDATE a = 1 WHERE b = 2").outcome).toBe("data");
+    expect(one("ALTER TABLE t DROP PARTITION 2024").outcome).toBe("unclassified");
+    expect(one("INSERT INTO t VALUES (1)").outcome).toBe("data");
+  });
+});