@coldsmirk/inkstone-sql 0.32.0 → 0.34.0

package/README.md

@@ -31,7 +31,7 @@ const runnable = runnableStatement(text, from, to, "postgres");
 if (runnable.kind === "one") {
   // Markers are read off the BLANKED form — `select '?'` binds nothing — and under the kind's
   // own binding rules: `markers.refusal` mirrors the engine scanner's own faults (mixed forms,
-  // `??` on mysql/dm, a hand-written `$1` beside a minted marker), so the editor can say so
+  // `??` on mysql/dm/clickhouse, a hand-written `$1` beside a minted marker), so the editor can say so
   // before the round trip does.
   const markers = statementMarkers(runnable.blanked, "postgres");
 }
@@ -41,7 +41,7 @@ Everything the intelligence answers goes through one lexical reader taken under
 
 ## The mirror invariant
 
-`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`internal/scan`) flag for flag. The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard.
+`noise.ts` (which runs of a statement are strings / comments / quoted names, per kind) and the marker grammar mirror [**polyglot's engine scanner**](https://github.com/coldsmirk/polyglot) (`sql/Placeholders`, over its profiles in `kinds/Dialect`) flag for flag, each kind under the two lexicons the sidecar reads it by: the database's own says where a statement ends and what is prose, and the one the kind's driver finds a `?` by says where the markers are — SQL Server nests a block comment, but Microsoft's driver ends one at its first close and binds a `?` past it; ClickHouse's driver reads a `?` as the conditional operator `a ? b : c` where a lone `:` follows it before any other `?`, and binds nothing through that `:` (`conditional.ts`). The scanner decides what actually binds; a reader that diverged would prompt for a parameter the engine refuses, or send a statement short of one it binds. **A scanner change requires a matching release of this package**, and the per-kind cases in `reader.test.ts` are the invariant's guard.
 
 ## Structured refusals
 

package/dist/{assist-BM4bNDhw.d.ts → assist-Cr2idunB.d.ts}

@@ -14,8 +14,11 @@
  * Doris (`doris`, StarRocks and SelectDB with it) speaks MySQL's protocol and grammar and reads
  * here as the MySQL idiom throughout, but its own parser admits no identifier past ASCII bare —
  * `患者` must be backticked where MySQL takes it as written — so it earned a kind for its spelling.
+ * ClickHouse (`clickhouse`) is a lexicon of its own on the engine — backslash escapes and backtick
+ * names as MySQL's, but `--` a comment without its space, `?` its own bind marker — and names its
+ * functions by their case (`toDate`, never `TODATE`).
  */
-type SqlKind = "postgres" | "mysql" | "oracle" | "sqlserver" | "dm" | "kingbase" | "doris";
+type SqlKind = "postgres" | "mysql" | "oracle" | "sqlserver" | "dm" | "kingbase" | "doris" | "clickhouse";
 /**
  * One table or view as the catalog reports it. Names carry the vendor's own casing — that casing
  * is information, and everything downstream preserves it.
@@ -170,9 +173,10 @@ type Runnable = {
    */
   text: string;
   /**
-   * The same span with everything the engine's own scanner skips whole — literals, comments and
-   * quoted names — overwritten by spaces, character for character, so offsets still line up with
-   * `text`. Anything reading the statement's syntax rather than its content must read this: in
+   * The statement as the engine's own scanner reads it when it is sent — under the lexicon the
+   * kind's driver finds a `?` by, from the statement's own start — with everything the scanner
+   * skips whole (literals, comments and quoted names) overwritten by spaces, character for
+   * character, so offsets still line up with `text`. A marker scan must read this: in
    * `select '?'` the `?` is prose, and a marker scan of the raw text would ask the operator for
    * a value the engine then refuses as an extra argument.
    */

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-BM4bNDhw.js";
+import { C as CatalogTable, S as CatalogFunction, _ as readCall, a as createSqlAssist, b as runnableStatement, c as SqlSource, d as CallRead, f as IdentifierRead, g as TableRef, h as StatementRead, i as SqlSignatureHelp, l as createSqlSchema, m as StatementContext, n as SqlCompletionCandidate, o as SqlCatalog, p as Runnable, r as SqlHoverCard, s as SqlSchema, t as SqlAssist, u as qualifiedName, v as readIdentifier, w as SqlKind, x as CatalogColumn, y as readStatement } from "./assist-Cr2idunB.js";
 //#region src/functions.d.ts
 /**
  * The function vocabulary this bench speaks: the curated floor this project wrote
@@ -78,11 +78,17 @@ interface SqlFunction {
  * manual: the words an integration engineer writes at this console, weighted toward reading — a
  * keyword or function missing here costs one suggestion, so the lists stay honest rather than
  * exhaustive. Everything is lowercase, the casing the bench itself writes (the tree's
- * `select * from`, the editor placeholder); completion re-cases it to follow the operator's hand.
+ * `select * from`, the editor placeholder); completion re-cases it to follow the operator's hand —
+ * but for the functions of a kind that names them by their case, spelled as the vendor spells them.
  */
 interface SqlDialect {
   keywords: string[];
   functions: SqlFunction[];
+  /**
+   * The kind names a function by its case (ClickHouse's `toDate`, never `TODATE`): its curated
+   * functions are written as listed, whatever the operator's hand.
+   */
+  functionsByCase?: boolean;
 }
 export declare const SQL_DIALECTS: Record<SqlKind, SqlDialect>;
 /**
@@ -133,11 +139,11 @@ export declare function joinGuesses(kind: SqlKind, target: SqlSource, others: Sq
  * Placeholder detection for what a run asks the operator for.
  *
  * This is **not** validation and must never become it: the engine-side scanner (the polyglot
- * sidecar's `internal/scan`) is the authority on what binds, it is lexical and per-dialect, and a second
- * implementation here would drift from it the first time a dialect gained a quoting form. All
- * this decides is whether the run has values to ask for, which form the parameter dialog
- * offers, and — where the statement is one the scanner refuses outright — the refusal, as a
- * code, so the editor can say so before the round trip does.
+ * sidecar's `sql/Placeholders`) is the authority on what binds, it is lexical and per-dialect,
+ * and a second implementation here would drift from it the first time a dialect gained a quoting
+ * form. All this decides is whether the run has values to ask for, which form the parameter
+ * dialog offers, and — where the statement is one the scanner refuses outright — the refusal, as
+ * a code, so the editor can say so before the round trip does.
  *
  * **Callers pass the statement's blanked form** (`Runnable.blanked`), never its raw text. A
  * disagreement with the engine's scanner is not cosmetic in either direction — it answers both
@@ -146,8 +152,10 @@ export declare function joinGuesses(kind: SqlKind, target: SqlSource, others: Sq
  * has no placeholder in it. Blanking is the reader's job because the reader already owns what is
  * prose and what is SQL for this page, and it takes that decision under the data source's own
  * lexical profile (`noise.ts`), mode for mode with the scanner — MySQL's `#` comments and
- * backslash escapes, Postgres's `$tag$` bodies, Oracle's `q'…'`, every kind's quoted names — so
- * what reaches this file is exactly the text the engine would mint markers from.
+ * backslash escapes, Postgres's `$tag$` bodies, Oracle's `q'…'`, every kind's quoted names,
+ * SQL Server's block comments as its driver ends them, and ClickHouse's conditional operator as
+ * its driver crosses it — so what reaches this file is exactly the text the engine would mint
+ * markers from.
  */
 /**
  * The binding form a statement's markers suggest.
@@ -159,8 +167,8 @@ type MarkerForm = "none" | "positional" | "named";
  *
  * - `"mixed-forms"` — the statement writes both `?` and `:name`; the scanner binds neither.
  * - `"question-escape-unsupported"` — `??` on a kind whose native form is itself `?` (MySQL,
- * 达梦): the escape has no rendering that survives, and neither dialect has a `?` operator to
- * escape in the first place.
+ * 达梦, ClickHouse): the escape has no rendering that survives, and none is needed — MySQL and
+ * 达梦 have no `?` operator, and ClickHouse's one, the conditional `a ? b : c`, is read as one.
  * - `"native-marker-collision"` — a marker hand-written in the kind's own bind form (`$1`,
  * `:1`, `@p1`) beside a `?`/`:name` the scanner would mint: both would bind the same slot.
  */
@@ -191,6 +199,11 @@ interface StatementMarkers {
 export declare function statementMarkers(statement: string, kind: SqlKind): StatementMarkers;
 //#endregion
 //#region src/noise.d.ts
+/**
+ * Which lexicon a text is read under: the database's own — where a statement ends, what is prose
+ * — or the one the kind's driver finds a `?` by, which the sidecar mints its markers under.
+ */
+type NoiseLexicon = "database" | "driver";
 /**
  * A run the reader must not look inside. `sealed` says the closing delimiter was found: a caret
  * right after a sealed run is back in the statement, while a caret at the end of an unterminated
@@ -223,9 +236,10 @@ interface BlankedSql {
 /**
  * The statement with its noise blanked out, char for char, so every offset survives — in the two
  * renderings the reader needs (see [BlankedSql]). One pass, mirroring the sidecar scanner's own
- * loop over its mutually exclusive lexical modes.
+ * loop over its mutually exclusive lexical modes, under the database's own lexicon unless the
+ * driver's is asked for.
  */
-export declare function blankNoise(text: string, kind: SqlKind): BlankedSql;
+export declare function blankNoise(text: string, kind: SqlKind, lexicon?: NoiseLexicon): BlankedSql;
 /**
  * Whether the caret sits inside a string or a comment, where the bench has nothing to say. A
  * quoted name is not one: it is a name the operator is writing, and the reader is about names.
@@ -373,4 +387,4 @@ export declare function spellQualifiedName(kind: SqlKind, table: {
   name: string;
 }): string;
 //#endregion
-export { type BenchFunction, type BindRefusal, type BlankedSql, type Bound, type BoundParams, type CallRead, type CatalogColumn, type CatalogFunction, type CatalogTable, type IdentifierRead, type JoinGuess, type JoinReason, type MarkerForm, type MarkerRefusal, type NoiseSpan, type ParamType, type ParamValue, type Runnable, type SqlAssist, type SqlCatalog, type SqlCompletionCandidate, type SqlDialect, type SqlFunction, type SqlFunctions, type SqlHoverCard, type SqlKind, type SqlScalar, type SqlSchema, type SqlSignatureHelp, type SqlSource, type StatementContext, type StatementMarkers, type StatementOrigin, type StatementRead, type TableRef, createSqlAssist, createSqlSchema, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement };
+export { type BenchFunction, type BindRefusal, type BlankedSql, type Bound, type BoundParams, type CallRead, type CatalogColumn, type CatalogFunction, type CatalogTable, type IdentifierRead, type JoinGuess, type JoinReason, type MarkerForm, type MarkerRefusal, type NoiseLexicon, type NoiseSpan, type ParamType, type ParamValue, type Runnable, type SqlAssist, type SqlCatalog, type SqlCompletionCandidate, type SqlDialect, type SqlFunction, type SqlFunctions, type SqlHoverCard, type SqlKind, type SqlScalar, type SqlSchema, type SqlSignatureHelp, type SqlSource, type StatementContext, type StatementMarkers, type StatementOrigin, type StatementRead, type TableRef, createSqlAssist, createSqlSchema, qualifiedName, readCall, readIdentifier, readStatement, runnableStatement };

package/dist/index.js

@@ -181,6 +181,63 @@ const MYSQL = dialect([
 	fn("group_concat", "group_concat(expr)", "Aggregate: joins each row's value into one string; takes `separator '…'`."),
 	fn("json_extract", "json_extract(json, path)", "Reads a JSON path, as in `'$.id'`.")
 ]);
+const CLICKHOUSE$1 = {
+	...dialect([
+		"final",
+		"prewhere",
+		"sample",
+		"array",
+		"global",
+		"any",
+		"asof",
+		"semi",
+		"anti",
+		"limit",
+		"offset",
+		"settings",
+		"format",
+		"totals",
+		"rollup",
+		"cube",
+		"ilike",
+		"interval",
+		"true",
+		"false"
+	], [
+		fn("now", "now(timezone)", "Current date and time, in the server's time zone unless one is named."),
+		fn("today", "today()", "Current date."),
+		fn("toDate", "toDate(value)", "Converts to a Date."),
+		fn("toDateTime", "toDateTime(value, timezone)", "Converts to a DateTime, in a time zone where one is named."),
+		fn("toString", "toString(value)", "Converts to a String."),
+		fn("toInt64", "toInt64(value)", "Converts to a 64-bit integer."),
+		fn("toFloat64", "toFloat64(value)", "Converts to a 64-bit float."),
+		fn("toStartOfDay", "toStartOfDay(time)", "Rounds a time down to the start of its day."),
+		fn("toStartOfHour", "toStartOfHour(time)", "Rounds a time down to the start of its hour."),
+		fn("toStartOfMonth", "toStartOfMonth(date)", "Rounds a date down to the first day of its month."),
+		fn("formatDateTime", "formatDateTime(time, format)", "Formats a time through a format string, as in `'%Y-%m-%d'`."),
+		fn("dateDiff", "dateDiff(unit, start, end)", "Unit boundaries crossed between two times, as in `dateDiff('day', a, b)`."),
+		fn("if", "if(condition, then, else)", "Ternary choice."),
+		fn("multiIf", "multiIf(condition, then, …, else)", "The value of the first condition that holds, or the last argument."),
+		fn("ifNull", "ifNull(value, fallback)", "The second argument when the first is NULL."),
+		fn("concat", "concat(value, …)", "Joins the arguments as strings."),
+		fn("length", "length(value)", "Bytes in a string, elements in an array; `lengthUTF8` counts characters."),
+		fn("substring", "substring(text, offset, length)", "`length` bytes from byte `offset`, counting from 1; `substringUTF8` counts characters."),
+		fn("position", "position(text, search)", "Byte position of a substring, counting from 1, or 0 when it is absent."),
+		fn("replaceAll", "replaceAll(text, search, replacement)", "Replaces every occurrence of a substring."),
+		fn("splitByChar", "splitByChar(separator, text)", "Splits a string on a one-character separator into an array."),
+		fn("JSONExtractString", "JSONExtractString(json, key, …)", "A string read out of JSON by key or index, empty where there is none."),
+		fn("has", "has(array, value)", "Whether the array holds the value."),
+		fn("arrayJoin", "arrayJoin(array)", "One row per element of the array."),
+		fn("countIf", "countIf(condition)", "Aggregate: rows for which the condition holds."),
+		fn("sumIf", "sumIf(value, condition)", "Aggregate: the sum over the rows for which the condition holds."),
+		fn("uniq", "uniq(expr)", "Aggregate: the distinct values, counted approximately."),
+		fn("uniqExact", "uniqExact(expr)", "Aggregate: the distinct values, counted exactly."),
+		fn("groupArray", "groupArray(expr)", "Aggregate: collects each row's value into an array."),
+		fn("argMax", "argMax(value, by)", "Aggregate: `value` from the row where `by` is largest."),
+		fn("any", "any(expr)", "Aggregate: one value of the group, whichever is met first.")
+	]),
+	functionsByCase: true
+};
 const SQL_DIALECTS = {
 	postgres: POSTGRES$1,
 	kingbase: POSTGRES$1,
@@ -222,7 +279,8 @@ const SQL_DIALECTS = {
 		fn("rtrim", "rtrim(text)", "Strips trailing whitespace."),
 		fn("string_agg", "string_agg(expr, delimiter)", "Aggregate: joins each row's value with a delimiter.")
 	]),
-	dm: ORACLE$1
+	dm: ORACLE$1,
+	clickhouse: CLICKHOUSE$1
 };
 function signatureParameters(signature) {
 	const open = signature.indexOf("(");
@@ -323,6 +381,13 @@ const TSQL_RESERVED = reservedWords(`
   tran transaction trigger truncate try_convert tsequal union unique unpivot update updatetext
   use user values varying view waitfor when where while with within writetext
 `);
+const CLICKHOUSE_RESERVED = reservedWords(`
+  all and anti any array as asc asof between by case cast collate cross cube desc distinct else
+  end except exists false fill final first format from full global group having ilike in inner
+  insert interpolate intersect interval into is join last left like limit not null nulls offset
+  on or order outer paste prewhere qualify right rollup sample select semi settings step table
+  then totals true union using values when where window with
+`);
 const ORACLE = {
 	open: "\"",
 	close: "\"",
@@ -357,10 +422,18 @@ const SPELLINGS = {
 		regular: /^[a-z_@#][\w@#$]*$/i,
 		reserved: TSQL_RESERVED
 	},
-	dm: ORACLE
+	dm: ORACLE,
+	clickhouse: {
+		open: "`",
+		close: "`",
+		backslash: true,
+		regular: /^[a-z_]\w*$/i,
+		reserved: CLICKHOUSE_RESERVED
+	}
 };
 function delimited(spelling, name) {
-	return `${spelling.open}${name.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
+	const escaped = spelling.backslash === true ? name.replaceAll("\\", () => "\\\\") : name;
+	return `${spelling.open}${escaped.replaceAll(spelling.close, () => spelling.close + spelling.close)}${spelling.close}`;
 }
 function spellIdentifier(kind, name) {
 	const spelling = SPELLINGS[kind];
@@ -421,6 +494,67 @@ function joinGuesses(kind, target, others) {
 	return [...found.values()];
 }
 //#endregion
+//#region src/conditional.ts
+function conditionalEnd(text, at) {
+	let index = at + 2;
+	while (index >= 0 && index < text.length) {
+		const ch = text[index];
+		if (ch === "?" || ch === ":") return ch === ":" && index + 1 < text.length && text[index + 1] !== ":" && text[index - 1] !== ":" ? index + 1 : -1;
+		index = skipped(text, index);
+	}
+	return -1;
+}
+function skipped(text, at) {
+	const ch = text[at];
+	if (ch === "'" || ch === "\"" || ch === "`") return quoted(text, at);
+	if (ch === "(" || ch === "[" || ch === "{") return group(text, at);
+	if (ch === "-" && text[at + 1] === "-") return lineEnd(text, at + 2);
+	if (ch === "/" && text[at + 1] === "*") return blockEnd(text, at + 2);
+	return at + 1;
+}
+function quoted(text, open) {
+	const quote = text[open];
+	for (let index = open + 1; index < text.length; index += 1) {
+		const ch = text[index];
+		if (ch === "\\") index += 1;
+		else if (ch === quote) {
+			if (text[index + 1] !== quote) return index + 1;
+			index += 1;
+		}
+	}
+	return -1;
+}
+const CLOSERS = {
+	"(": ")",
+	"[": "]",
+	"{": "}"
+};
+function group(text, open) {
+	const close = CLOSERS[text[open]];
+	let index = open + 1;
+	while (index >= 0 && index < text.length) {
+		if (text[index] === close) return index + 1;
+		index = skipped(text, index);
+	}
+	return -1;
+}
+function lineEnd(text, from) {
+	const end = text.indexOf("\n", from);
+	return end > from ? end + 1 : text.length;
+}
+function blockEnd(text, from) {
+	let depth = 1;
+	for (let index = from; index + 1 < text.length; index += 1) if (text[index] === "/" && text[index + 1] === "*") {
+		depth += 1;
+		index += 1;
+	} else if (text[index] === "*" && text[index + 1] === "/") {
+		depth -= 1;
+		index += 1;
+		if (depth === 0) return index + 1;
+	}
+	return -1;
+}
+//#endregion
 //#region src/noise.ts
 const BASE = {
 	backslashEscapes: false,
@@ -432,7 +566,22 @@ const BASE = {
 	dollarQuoting: false,
 	escapeStrings: false,
 	nestedBlockComments: false,
-	alternativeQuoting: false
+	alternativeQuoting: false,
+	backslashInBackticks: false,
+	conditionalOperator: false
+};
+const SQLSERVER = {
+	...BASE,
+	bracketIdentifiers: true,
+	nestedBlockComments: true
+};
+const CLICKHOUSE = {
+	...BASE,
+	backslashEscapes: true,
+	hashLineComments: true,
+	backtickIdentifiers: true,
+	nestedBlockComments: true,
+	backslashInBackticks: true
 };
 const NOISE_PROFILES = {
 	postgres: {
@@ -461,16 +610,24 @@ const NOISE_PROFILES = {
 		...BASE,
 		alternativeQuoting: true
 	},
-	sqlserver: {
-		...BASE,
-		bracketIdentifiers: true
-	},
+	sqlserver: SQLSERVER,
 	dm: BASE,
 	kingbase: {
 		...BASE,
 		escapeStrings: true,
 		nestedBlockComments: true,
 		dollarQuoting: true
+	},
+	clickhouse: CLICKHOUSE
+};
+const DRIVER_PROFILES = {
+	sqlserver: {
+		...SQLSERVER,
+		nestedBlockComments: false
+	},
+	clickhouse: {
+		...CLICKHOUSE,
+		conditionalOperator: true
 	}
 };
 const WORD_START = /[a-z_\u{0080}-\u{FFFF}]/iu;
@@ -575,10 +732,14 @@ function opensLineComment(text, from, profile) {
 	const after = text[from + 2];
 	return !profile.lineCommentNeedsSpace || after === void 0 || after <= " ";
 }
-let lastBlanked = null;
-function blankNoise(text, kind) {
-	if (lastBlanked !== null && lastBlanked.text === text && lastBlanked.kind === kind) return lastBlanked.result;
-	const profile = NOISE_PROFILES[kind];
+const lastBlanked = {
+	database: null,
+	driver: null
+};
+function blankNoise(text, kind, lexicon = "database") {
+	const last = lastBlanked[lexicon];
+	if (last !== null && last.text === text && last.kind === kind) return last.result;
+	const profile = lexicon === "driver" ? DRIVER_PROFILES[kind] ?? NOISE_PROFILES[kind] : NOISE_PROFILES[kind];
 	const withNames = text.split("");
 	const blanked = text.split("");
 	const spans = [];
@@ -600,11 +761,18 @@ function blankNoise(text, kind) {
 		const ch = text[at];
 		if (ch === "'") skip(closeDelimited(text, at + 1, "'", profile.backslashEscapes), false);
 		else if (ch === "\"") skip(closeDelimited(text, at + 1, "\"", profile.backslashEscapes), !profile.doubleQuotedStrings);
-		else if (ch === "`" && profile.backtickIdentifiers) skip(closeDelimited(text, at + 1, "`", false), true);
+		else if (ch === "`" && profile.backtickIdentifiers) skip(closeDelimited(text, at + 1, "`", profile.backslashInBackticks), true);
 		else if (ch === "[" && profile.bracketIdentifiers) skip(closeBracket(text, at + 1), true);
 		else if (opensLineComment(text, at, profile)) skip(closeLine(text, at), false);
 		else if (ch === "/" && text[at + 1] === "*") skip(closeBlock(text, at + 2, profile.nestedBlockComments), false);
-		else if (ch === "$" && profile.dollarQuoting) {
+		else if (ch === "?" && profile.conditionalOperator) {
+			const end = conditionalEnd(text, at);
+			if (end < 0) at += text[at + 1] === "?" ? 2 : 1;
+			else skip({
+				end,
+				sealed: true
+			}, false);
+		} else if (ch === "$" && profile.dollarQuoting) {
 			const quoted = closeDollarQuoted(text, at);
 			if (quoted === null) at += 1;
 			else skip(quoted, false);
@@ -622,7 +790,7 @@ function blankNoise(text, kind) {
 		blanked: blanked.join(""),
 		spans
 	};
-	lastBlanked = {
+	lastBlanked[lexicon] = {
 		text,
 		kind,
 		result
@@ -918,10 +1086,11 @@ function runnableStatement(text, from, to, kind) {
 	if (spans.length === 0) return { kind: "none" };
 	if (selected && spans.length > 1) return { kind: "several" };
 	const span = spans[0];
+	const statement = text.slice(span.from, span.to);
 	return {
 		kind: "one",
-		text: text.slice(span.from, span.to),
-		blanked: blanked.slice(span.from, span.to),
+		text: statement,
+		blanked: blankNoise(statement, kind, "driver").blanked,
 		from: span.from,
 		to: span.to,
 		alone: statementSpans(text, blanked, 0, text.length).length <= 1
@@ -1023,7 +1192,7 @@ function expansionCandidate(kind, sources, replacesStar) {
 	};
 }
 function createSqlCompletion(kind, schema, functions) {
-	const { keywords } = SQL_DIALECTS[kind];
+	const { keywords, functionsByCase = false } = SQL_DIALECTS[kind];
 	const spelled = /* @__PURE__ */ new Map();
 	async function wordCandidates(typed) {
 		const upper = typed !== "" && typed === typed.toUpperCase() && typed !== typed.toLowerCase();
@@ -1039,7 +1208,7 @@ function createSqlCompletion(kind, schema, functions) {
 				sortGroup: RANK_KEYWORD
 			};
 		}), ...known.map((entry) => {
-			const name = entry.origin === "curated" ? spell(entry.name) : entry.name;
+			const name = entry.origin === "curated" && !functionsByCase ? spell(entry.name) : entry.name;
 			const written = entry.origin === "curated" ? name : spellCallable(kind, name);
 			const call = entry.qualifier === "" ? written : `${spellIdentifier(kind, entry.qualifier)}.${written}`;
 			return {
@@ -1161,7 +1330,8 @@ const DIALECTS = {
 	oracle: "plsql",
 	dm: "plsql",
 	sqlserver: "transactsql",
-	kingbase: "postgresql"
+	kingbase: "postgresql",
+	clickhouse: "clickhouse"
 };
 const PLACEHOLDERS = String.raw`\?|:[A-Za-z_]\w*`;
 function sentinelFor(text) {
@@ -1426,8 +1596,12 @@ function createSqlAssist(kind, catalog) {
 }
 //#endregion
 //#region src/markers.ts
-const SCAN = /[A-Z_\u0080-\uFFFF][\w$\u0080-\uFFFF]*|(?<qq>\?\?)|::|(?<q>\?)|:(?<name>[A-Z_]\w*)|(?<colonDigits>:\d+)|(?<dollarDigits>\$\d+)|(?<atDigits>@P\d+)/gi;
-const QUESTION_IS_NATIVE = /* @__PURE__ */ new Set(["mysql", "dm"]);
+const SCAN = /[A-Z_\u0080-\uFFFF][\w$\u0080-\uFFFF]*|(?<qq>\?\?)|::|(?<q>\?)|(?<!\.):(?<name>[A-Z_]\w*)|(?<colonDigits>:\d+)|(?<dollarDigits>\$\d+)|(?<atDigits>@P\d+)/gi;
+const QUESTION_IS_NATIVE = /* @__PURE__ */ new Set([
+	"mysql",
+	"dm",
+	"clickhouse"
+]);
 const NATIVE_GROUP = {
 	postgres: "dollarDigits",
 	mysql: null,
@@ -1435,7 +1609,8 @@ const NATIVE_GROUP = {
 	oracle: "colonDigits",
 	sqlserver: "atDigits",
 	dm: null,
-	kingbase: "dollarDigits"
+	kingbase: "dollarDigits",
+	clickhouse: null
 };
 function statementMarkers(statement, kind) {
 	const names = [];

package/dist/monaco.d.ts

@@ -1,4 +1,4 @@
-import { t as SqlAssist } from "./assist-BM4bNDhw.js";
+import { t as SqlAssist } from "./assist-Cr2idunB.js";
 import * as monacoEditor from "monaco-editor";
 import { IDisposable } from "monaco-editor";
 //#region src/monaco.d.ts

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { t as SqlAssist } from "./assist-BM4bNDhw.js";
+import { t as SqlAssist } from "./assist-Cr2idunB.js";
 import { ConsoleCaret, ConsoleEditorHandle, ConsoleEditorProps } from "@coldsmirk/inkstone-react/monaco";
 import { ReactNode } from "react";
 //#region src/react.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-sql",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "Schema-aware SQL editing intelligence for Monaco: lexical statement reading under per-dialect noise profiles, catalog-driven completion/hover/signature help, unified-placeholder awareness, formatting, and a drop-in React SQL editor.",
   "keywords": [
     "sql",
@@ -48,12 +48,12 @@
   "devDependencies": {
     "monaco-editor": "^0.57.0",
     "react": "^19.3.0",
-    "@coldsmirk/inkstone-react": "^0.32.0"
+    "@coldsmirk/inkstone-react": "^0.34.0"
   },
   "peerDependencies": {
     "monaco-editor": "^0.57.0",
     "react": ">=19",
-    "@coldsmirk/inkstone-react": "^0.32.0"
+    "@coldsmirk/inkstone-react": "^0.34.0"
   },
   "peerDependenciesMeta": {
     "@coldsmirk/inkstone-react": {