sqllens 1.5.0 → 1.6.0

package/dist/api.d.ts

@@ -116,14 +116,14 @@ export type { Token, TokenRole } from "./token/token.js";
 export { SqlDocument, type DocumentAnalysis, type StatementCell, type DocumentVariant, type UnionCte, } from "./document/document.js";
 export { LineIndex } from "./document/line-index.js";
 export type { StatementCellSpan } from "./document/split.js";
-export { complete, completeAt, type Completion } from "./completion/complete.js";
+export { complete, completeAt, type Completion, type CompletionResult, type ReplaceRange, } from "./completion/complete.js";
 export { jinjaSlotAt, type JinjaSlot } from "./completion/jinja-slot.js";
 export { signatureAt, type SignatureHelpInfo, type SignatureLabel } from "./signature/signature.js";
 export { SIGNATURES, lookupSignature, hasSignature, type FnSignature, type ParamSig } from "./signature/signatures.js";
 export { renderSignature, type RenderSignatureOptions } from "./signature/render.js";
 export { FN_DOCS, lookupFnDoc, type FnDoc } from "./signature/docs.js";
 export { referencesAt, type Occurrence, type Occurrences } from "./references/references.js";
-export { dialectSymbols, type DialectSymbols } from "./dialect-symbols.js";
+export { dialectSymbols, dialectVocabulary, type DialectSymbols, type DialectVocabulary } from "./dialect-symbols.js";
 export { CallbackSchema, type SchemaProvider, type TableResolver } from "./qualify/schema-provider.js";
 export { DERIVED_DIALECTS, resolveDialect } from "./derived-dialects.js";
 export { foldIdentifier, displayName } from "./dialect-behavior/public-fold.js";

package/dist/api.js

@@ -204,7 +204,7 @@ export { SqlDocument, } from "./document/document.js";
 export { LineIndex } from "./document/line-index.js";
 // Scope-aware completion over a SqlDocument — the broken-input editor feature (keywords + schema
 // tables/columns + function names at the caret). Total: never throws.
-export { complete, completeAt } from "./completion/complete.js";
+export { complete, completeAt, } from "./completion/complete.js";
 // The NEUTRAL half of jinja completion: which call + arg slot the caret sits in inside a jinja tag
 // (`{{ ref('cu│` → { callee: "ref", argIndex: 0, prefix: "cu" }). Carries no dbt vocabulary; a
 // consumer maps callee + argIndex to a role and supplies candidates. Reuses the parsed tags.
@@ -225,7 +225,7 @@ export { FN_DOCS, lookupFnDoc } from "./signature/docs.js";
 export { referencesAt } from "./references/references.js";
 // Per-dialect function/keyword/type-name membership sets — for lint-style "is this identifier a
 // known X for this dialect?" checks. Computed once per dialect and cached.
-export { dialectSymbols } from "./dialect-symbols.js";
+export { dialectSymbols, dialectVocabulary } from "./dialect-symbols.js";
 // The catalog interface the whole pipeline resolves against, plus its resolve-on-demand
 // implementation. `Schema` (a full upfront mapping) and `CallbackSchema` (a host-driven
 // lazy resolver whose prime() bumps a version to invalidate SqlDocument.analyze's memo) both

package/dist/bigquery/lower.js

@@ -1482,9 +1482,11 @@ function lowerLeaf(node) {
         case P.RULE_floating_point_literal:
         case P.RULE_date_or_time_literal:
         case P.RULE_range_literal:
+            return { kind: "literal", text: node.getText(), cst: node };
         case P.RULE_parameter_expression:
+            return lowerParameterExpression(node);
         case P.RULE_system_variable_expression:
-            return { kind: "literal", text: node.getText(), cst: node };
+            return lowerSystemVariableExpression(node);
         case P.RULE_identifier:
             return { kind: "column", parts: [identText(node)], partSpans: partSpansOf([node]), cst: node };
         case P.RULE_path_expression:
@@ -1844,7 +1846,12 @@ function columnsOf(expr, acc, clause) {
             break;
         case "subscript":
             columnsOf(expr.base, acc, clause);
-            columnsOf(expr.index, acc, clause);
+            if (expr.index)
+                columnsOf(expr.index, acc, clause);
+            if (expr.end)
+                columnsOf(expr.end, acc, clause);
+            if (expr.step)
+                columnsOf(expr.step, acc, clause);
             break;
         case "lambda":
             columnsOf(expr.body, acc, clause);
@@ -1949,6 +1956,25 @@ function extractExpressionSubqueries(select, fromQueries) {
     return out;
 }
 // --- name helpers ----------------------------------------------------------------
+/** parameter_expression: named_parameter_expression | QUESTION_SYMBOL
+ *  (cloud.google.com/bigquery/docs/parameterized-queries). Bare `?` carries no name/ordinal —
+ *  BigQuery's positional form has no explicit index, so `ordinal` stays a consumer derivation,
+ *  never fabricated here. `@name` resolves through named_parameter_expression's single
+ *  dot_identifier; reusing pathParts is safe since that rule holds exactly one dot_identifier
+ *  and no identifier head, so it degenerates to a one-element (dot-split, backtick-stripped) path. */
+function lowerParameterExpression(node) {
+    const named = firstOfRule(node, P.RULE_named_parameter_expression);
+    if (!named)
+        return { kind: "parameter", text: node.getText(), cst: node };
+    return { kind: "parameter", text: node.getText(), name: pathParts(named).join("."), cst: node };
+}
+/** system_variable_expression: ATAT_SYMBOL dot_identifier (DOT_SYMBOL dot_identifier)* — a script-
+ *  level system variable (cloud.google.com/bigquery/docs/reference/system-variables), e.g.
+ *  `@@dataset_id` or the dotted `@@a.b`. `name` is the dotted path with the `@@` sigil stripped;
+ *  pathParts already handles this shape (no identifier head, one-or-more dot_identifier tail). */
+function lowerSystemVariableExpression(node) {
+    return { kind: "variable", text: node.getText(), name: pathParts(node).join("."), system: true, cst: node };
+}
 /** path_expression: identifier (DOT dot_identifier)* — the dotted parts. The head is an identifier;
  *  later parts are dot_identifier (which may be a reserved keyword after the dot). A single
  *  backtick-quoted identifier may itself hold a dotted path (`proj.ds.t`), so split each part on `.`. */

package/dist/completion/complete.d.ts

@@ -1,19 +1,40 @@
 import type { SqlDocument } from "../document/document.js";
 import type { SchemaProvider } from "../qualify/schema-provider.js";
-/** One completion candidate. The editor filters this list by the typed prefix and applies the
- *  chosen label at the caret; we only produce the labels, anchored at the caret offset. The
- *  `"template"` kind is a host candidate for a jinja call slot (a dbt model for a ref's arg). */
+/** One completion candidate, already pruned to the typed prefix (2026-07-12 ruling) and applied at
+ *  the caret / `CompletionResult.replaceRange`. The `"template"` kind is a host candidate for a
+ *  jinja call slot (a dbt model for a ref's arg) — its own, separately-decided contract (the
+ *  consumer still filters those by the typed prefix; see complete.jinja-candidates.test.ts). */
 export interface Completion {
     label: string;
     kind: "keyword" | "column" | "table" | "cte" | "namespace" | "function" | "template";
     /** Extra display info, e.g. a column's type when the schema knows it. */
     detail?: string;
 }
+/** The caret-anchored span of the partial identifier/keyword the candidates were pruned against —
+ *  `text.slice(start, end)` is what's already typed. `start` includes an opening delimiter when the
+ *  caret sits inside a quoted/bracketed/backtick-quoted identifier (`"my_t`, `` `my_t ``, `[my_t`),
+ *  so an editor that replaces this span never leaves a stray leading quote. `end` never extends past
+ *  the caret (`offset`) — even where a dialect's lexer greedily swallows an unterminated quoted
+ *  identifier past the caret, only the already-typed portion is ever reported or matched. */
+export interface ReplaceRange {
+    start: number;
+    end: number;
+}
+/** completeAt()'s result: an ordinary `Completion[]` (`.map`/`.filter`/iteration/`.length` all work
+ *  exactly as before — every existing consumer sees no change) carrying one optional extra
+ *  property, the same "array with named extras" shape TypeScript's own `RegExpMatchArray` uses for
+ *  `String.prototype.match`. `replaceRange` is present only when the caret sits inside a partially
+ *  typed word; an empty-prefix caret (a token boundary — nothing typed yet) returns a plain array
+ *  with no `replaceRange`, byte-identical to the pre-pruning contract. */
+export interface CompletionResult extends Array<Completion> {
+    replaceRange?: ReplaceRange;
+}
 /**
- * Completion candidates for the caret at `offset` in `doc`. Schema-aware when a `Schema` is given
- * (table names + column types). NEVER throws: on broken / mid-edit input it still returns the
- * keyword candidates the walk can reach.
+ * Completion candidates for the caret at `offset` in `doc`, pruned to the identifier/keyword
+ * fragment already typed there (case-insensitive, dialect-fold-aware; plain prefix match — never
+ * fuzzy). Schema-aware when a `Schema` is given (table names + column types). NEVER throws: on
+ * broken / mid-edit input it still returns the keyword candidates the walk can reach.
  */
-export declare function completeAt(doc: SqlDocument, offset: number, schema?: SchemaProvider): Completion[];
+export declare function completeAt(doc: SqlDocument, offset: number, schema?: SchemaProvider): CompletionResult;
 /** @deprecated Use completeAt — same function, uniform cursor-verb naming. */
 export declare const complete: typeof completeAt;

package/dist/completion/complete.js

@@ -16,6 +16,7 @@
 // throws — broken input still yields at least the keyword candidates.
 // ---------------------------------------------------------------------------
 import { Token } from "antlr4ng";
+import { debugRethrow } from "../debug.js";
 import { nodeAt } from "../document/node-at.js";
 import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { DefaultTemplateProvider } from "../qualify/template-provider.js";
@@ -26,9 +27,10 @@ import { jinjaSlotAt } from "./jinja-slot.js";
 import { COMPLETION_CONFIG } from "./config.js";
 import { completionMeta } from "./parser-factory.js";
 /**
- * Completion candidates for the caret at `offset` in `doc`. Schema-aware when a `Schema` is given
- * (table names + column types). NEVER throws: on broken / mid-edit input it still returns the
- * keyword candidates the walk can reach.
+ * Completion candidates for the caret at `offset` in `doc`, pruned to the identifier/keyword
+ * fragment already typed there (case-insensitive, dialect-fold-aware; plain prefix match — never
+ * fuzzy). Schema-aware when a `Schema` is given (table names + column types). NEVER throws: on
+ * broken / mid-edit input it still returns the keyword candidates the walk can reach.
  */
 export function completeAt(doc, offset, schema) {
     try {
@@ -36,8 +38,7 @@ export function completeAt(doc, offset, schema) {
     }
     catch (e) {
         // Total by contract: a walk/parse hiccup must not surface to the editor.
-        if (process.env.SQLLENS_DEBUG_COMPLETE)
-            throw e;
+        debugRethrow(e);
         return [];
     }
 }
@@ -84,7 +85,7 @@ function collect(doc, offset, schema) {
         ...(cell ? cell.tokens : doc.tokens),
         { type: Token.EOF, channel: Token.DEFAULT_CHANNEL, start: end, text: "" },
     ];
-    const caretIdx = caretTokenIndex(walkTokens, offset);
+    const caretIdx = caretTokenIndex(walkTokens, offset, cfg);
     const cand = collectCandidates(meta.atn, meta.entryRuleIndex, walkTokens, caretIdx, cfg.preferredRules, cfg.ignoredTokens);
     const out = [];
     const seen = new Set(); // dedup by `${kind}\0${label}`
@@ -131,7 +132,8 @@ function collect(doc, offset, schema) {
         // failure the bare-slot fallback covers. Its member twin: read `FROM/JOIN name [alias]`
         // pairs off the token stream and answer the matching relation's schema columns.
         if (scoped.length === 0 && schema) {
-            for (const c of qualifiedFallbackColumns(walkTokens, cfg, path.parts, schema, dialect))
+            const fallback = qualifiedFallbackColumns(walkTokens, cfg, path.parts, schema, dialect, doc.templated?.tags, doc.text);
+            for (const c of fallback)
                 add(c);
         }
     }
@@ -158,7 +160,93 @@ function collect(doc, offset, schema) {
                 add({ label: fn, kind: "function" });
         }
     }
-    return out;
+    return pruneByPrefix(out, walkTokens, offset, cfg, doc.text, dialect);
+}
+/** SQL identifier-quoting delimiters recognized across all ten dialects
+ *  (docs/identifier-delimiter-contract.md) — used only to recognize a PARTIAL, possibly
+ *  unterminated quoted identifier under the caret; a dialect's own quoting/case rules stay put in
+ *  src/<dialect>/fold.ts. */
+const CLOSE_FOR_OPEN = { '"': '"', "`": "`", "[": "]" };
+/** The identifier/keyword fragment under (or immediately preceding) the caret, read off the
+ *  document's OWN token stream — never re-lexed. Two shapes recognized:
+ *   - a bare word (keyword or identifier) the caret sits inside/at the end of (`SEL|`, `ifn|`) —
+ *     word-START only (`[A-Za-z_]`), so a numeric literal (`… WHERE x > 10|`) is never mistaken
+ *     for an identifier prefix;
+ *   - a delimited identifier: either ONE token spanning both delimiters (`cfg.nameTokens` — a
+ *     complete `"a"`/`` `a` ``/`[a]`, or an unterminated one some dialects lex greedily to EOF), or
+ *     a lone opening-delimiter character immediately followed by a bare identifier token (the
+ *     lexer error-recovery split other dialects produce for an unterminated `` `a `` / `"a` — the
+ *     delimiter alone fails to match any token and is skipped, the identifier body then lexes
+ *     cleanly on its own).
+ *  Returns undefined at a token boundary — nothing partially typed (the empty-prefix case, left
+ *  completely unpruned). The returned span never extends past `offset`: even where a dialect's
+ *  lexer greedily swallows an unterminated quoted identifier to EOF, only the already-typed portion
+ *  is ever reported. */
+function identifierPrefixAt(toks, offset, cfg, text) {
+    for (let i = 0; i < toks.length; i++) {
+        const t = toks[i];
+        if (!t || t.channel !== Token.DEFAULT_CHANNEL)
+            continue;
+        const nameLike = /^[A-Za-z_]/.test(t.text) || cfg.nameTokens.has(t.type);
+        if (nameLike && t.start < offset && offset <= t.start + t.text.length) {
+            let start = t.start;
+            // A lone opening-delimiter token immediately before this one (the split-recovery case) —
+            // fold it into the same partial identifier so the replace range covers it too.
+            for (let j = i - 1; j >= 0; j--) {
+                const p = toks[j];
+                if (!p || p.channel !== Token.DEFAULT_CHANNEL)
+                    continue;
+                if (p.start + p.text.length === start && Object.hasOwn(CLOSE_FOR_OPEN, p.text))
+                    start = p.start;
+                break;
+            }
+            return { start, raw: text.slice(start, offset) };
+        }
+        if (t.start >= offset)
+            return undefined; // moved past the caret — nothing partially typed here
+    }
+    return undefined;
+}
+/** Fold a (possibly partial/unterminated) identifier fragment to the same identity space
+ *  `behavior.fold` gives a COMPLETE identifier. A partial `"a`/`` `a `` /`[a` has no closing
+ *  delimiter yet — `fold()`'s own unwrap requires one to recognize it as quoted — so this
+ *  synthesizes the matching close for the fold call only; the raw text / replace range reported
+ *  elsewhere are untouched. Folding an already-complete candidate label through this is a no-op. */
+function foldForPrefixMatch(behavior, raw, kind) {
+    const open = raw[0];
+    const close = open ? CLOSE_FOR_OPEN[open] : undefined;
+    const closed = close && !raw.endsWith(close) ? raw + close : raw;
+    return behavior.fold(closed, kind);
+}
+/** Post-filters the assembled SQL-slot candidates by the identifier/keyword fragment under the
+ *  caret (2026-07-12 ruling: "completeAt must return only candidates that validly complete at the
+ *  caret right now, pruned by the word already typed" — the library holds the token stream, CST,
+ *  and dialect fold rules, so it prunes here instead of handing the consumer the whole per-slot
+ *  set). An empty-prefix caret (a token boundary — nothing partially typed) returns `out`
+ *  completely unchanged: byte-identical to the pre-pruning contract, no `replaceRange`. Keywords
+ *  fold plain ASCII-case-insensitive (every dialect's keywords are case-insensitive, unlike
+ *  identifiers); identifier-kind candidates (column/table/cte/namespace/function) fold through the
+ *  dialect's own identity-key rule, `"table"` kind for `table` candidates (only BigQuery's table
+ *  case rule differs from the rest). Plain-prefix `startsWith` only — never fuzzy (never-wrong: no
+ *  guessed matches). Jinja template/call-slot candidates (returned earlier in `collect`, from
+ *  `templateCompletions`) are OUT of this — that path has its own, separately-decided "editor
+ *  filters" contract (tests/completion/complete.jinja-candidates.test.ts). */
+function pruneByPrefix(out, toks, offset, cfg, text, dialect) {
+    const prefix = identifierPrefixAt(toks, offset, cfg, text);
+    if (!prefix)
+        return out;
+    const behavior = resolveBehavior(dialect);
+    const keywordPrefix = prefix.raw.toLowerCase();
+    const otherPrefix = foldForPrefixMatch(behavior, prefix.raw, "other");
+    const tablePrefix = foldForPrefixMatch(behavior, prefix.raw, "table");
+    const pruned = out.filter((c) => {
+        if (c.kind === "keyword")
+            return c.label.toLowerCase().startsWith(keywordPrefix);
+        const kind = c.kind === "table" ? "table" : "other";
+        return foldForPrefixMatch(behavior, c.label, kind).startsWith(kind === "table" ? tablePrefix : otherPrefix);
+    });
+    pruned.replaceRange = { start: prefix.start, end: offset };
+    return pruned;
 }
 /** The host's candidates for a jinja call slot, as completions. The template provider carries them,
  *  so this reads the `schema` when it is one (a DbtTemplateProvider IS a SchemaProvider, and the host
@@ -219,18 +307,22 @@ function visibleCteNames(scopes, ast, offset) {
  *  convention):
  *   1. the token being TYPED — a word-like token whose span CONTAINS the caret (start < offset <=
  *      end). A caret at the end of `ifn` completes `ifn`; it does not mean the slot is filled.
- *      Word-like only: punctuation is never partially typed, so `abs(|` keeps rule 2.
+ *      Word-like OR a delimited identifier token (cfg.nameTokens: `` `a` ``/`"a"`/`[a]`) counts too —
+ *      without it, a caret inside a quoted identifier fell through to rule 2 and reported the
+ *      position of whatever token happened to follow it. Punctuation is never partially typed,
+ *      so `abs(|` keeps rule 2.
  *   2. between tokens — the first default-channel token whose `.start >= offset`; for an
  *      end-of-input caret that is the EOF sentinel's index (last entry).
  *  `toks` is the document's own token stream (doc coordinates) with the EOF sentinel appended.
  *  Source order makes one pass sufficient: a containing token starts before any `.start >= offset`
  *  token, so rule 1 fires first whenever it applies. */
-function caretTokenIndex(toks, offset) {
+function caretTokenIndex(toks, offset, cfg) {
     for (let i = 0; i < toks.length; i++) {
         const t = toks[i];
         if (!t || t.channel !== Token.DEFAULT_CHANNEL)
             continue;
-        if (/^\w/.test(t.text) && t.start < offset && offset <= t.start + t.text.length)
+        const wordLike = /^\w/.test(t.text) || cfg.nameTokens.has(t.type);
+        if (wordLike && t.start < offset && offset <= t.start + t.text.length)
             return i;
         if (t.start >= offset)
             return i;
@@ -322,16 +414,45 @@ function qualifiedSourceColumns(scopes, ast, offset, qualParts, dialect, schema)
 /** The member-position twin of `fromRelationColumns` (#38): when the scope is empty (the dangling
  *  dot broke the FROM parse), read `FROM/JOIN name(.name)* [AS] [alias]` off the token stream and
  *  answer the columns of the ONE relation the qualifier matches — the alias when present, else the
- *  name's own trailing parts. No match (or several) answers [] — never a fabricated union. */
-function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect) {
+ *  name's own trailing parts. A templated source ({{ ref() }} c) is resolved through the provider
+ *  (relationOf), matching the qualifier to its alias — the same seam `fromRelationColumns` uses. No
+ *  match (or several) answers [] — never a fabricated union. */
+function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect, tags, text) {
     if (cfg.relationKeywordTokens.size === 0)
         return [];
     const b = resolveBehavior(dialect);
     const toks = walkTokens.filter((t) => t.channel === Token.DEFAULT_CHANNEL);
     const hits = [];
+    const colHits = (cols) => {
+        if (cols)
+            hits.push(cols.map((c) => ({ label: c.name, kind: "column", detail: c.type })));
+    };
     for (let i = 0; i + 1 < toks.length; i++) {
         if (!cfg.relationKeywordTokens.has(toks[i].type))
             continue;
+        // A templated source ({{ ref('customers') }} c) blanks to a channel-2 tag the filter drops, so
+        // the next SQL token is the ALIAS, not a relation name. Resolve the relation through the provider
+        // (relationOf) — the same seam fromRelationColumns uses — and match the qualifier to that alias;
+        // without this, the alias got read AS the relation name and columnsFor answered nothing.
+        const kw = toks[i];
+        const next = toks[i + 1];
+        const tag = tags?.find((t) => t.kind === "call" && t.tagSpan.start >= kw.start && t.tagSpan.start < next.start);
+        if (tag) {
+            if (schema instanceof DefaultTemplateProvider) {
+                let a = i + 1;
+                if (toks[a] && b.fold(toks[a].text) === "as")
+                    a++;
+                const alias = toks[a];
+                if (alias &&
+                    cfg.nameTokens.has(alias.type) &&
+                    qualParts.length === 1 &&
+                    b.fold(qualParts[0]) === b.fold(alias.text)) {
+                    const rel = schema.relationOf(callOf(tag, text));
+                    colHits(rel ? (rel.columns ?? schema.columnsFor(rel.nameParts, dialect)) : undefined);
+                }
+            }
+            continue; // templated source handled (or unresolvable) — never treat the alias as a relation name
+        }
         let j = i + 1;
         if (!toks[j] || !cfg.nameTokens.has(toks[j].type))
             continue;
@@ -352,9 +473,7 @@ function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect) {
                 qualParts.every((p, k) => b.fold(p, "table") === b.fold(parts[parts.length - qualParts.length + k], "table"));
         if (!matches)
             continue;
-        const cols = schema.columnsFor(parts, dialect);
-        if (cols)
-            hits.push(cols.map((c) => ({ label: c.name, kind: "column", detail: c.type })));
+        colHits(schema.columnsFor(parts, dialect));
     }
     return hits.length === 1 ? hits[0] : [];
 }

package/dist/completion/config.js

@@ -84,7 +84,10 @@ const BIGQUERY_TABLE_RULES = new Set([GoogleSQLParser.RULE_table_path_expression
 const BIGQUERY_COLUMN_RULES = new Set([GoogleSQLParser.RULE_identifier]);
 const BIGQUERY_PREFERRED = new Set([...BIGQUERY_TABLE_RULES, ...BIGQUERY_COLUMN_RULES]);
 const BIGQUERY_RELATION_KEYWORDS = new Set([GoogleSQLLexer.FROM_SYMBOL, GoogleSQLLexer.JOIN_SYMBOL]);
-const BIGQUERY_NAME_TOKENS = new Set([GoogleSQLLexer.IDENTIFIER]);
+// UNCLOSED_ESCAPED_IDENTIFIER is the dedicated recovery token GoogleSQL's lexer emits for a
+// backtick-quoted identifier with no closing backtick yet (`` `a `` mid-typing) — completion's
+// caret-in-a-partial-identifier detection needs it alongside the ordinary closed-form token.
+const BIGQUERY_NAME_TOKENS = new Set([GoogleSQLLexer.IDENTIFIER, GoogleSQLLexer.UNCLOSED_ESCAPED_IDENTIFIER]);
 // ── Redshift (Bytebase/Postgres-derived fork) ───────────────────────────────
 //   post-FROM   → relation_expr (the relation slot; the leaf `identifier` also surfaces post-FROM
 //                  but never in column position, so tableRules uses relation_expr).
@@ -93,7 +96,13 @@ const REDSHIFT_TABLE_RULES = new Set([RedshiftParser.RULE_relation_expr]);
 const REDSHIFT_COLUMN_RULES = new Set([RedshiftParser.RULE_a_expr]);
 const REDSHIFT_PREFERRED = new Set([...REDSHIFT_TABLE_RULES, ...REDSHIFT_COLUMN_RULES]);
 const REDSHIFT_RELATION_KEYWORDS = new Set([RedshiftLexer.FROM, RedshiftLexer.JOIN]);
-const REDSHIFT_NAME_TOKENS = new Set([RedshiftLexer.Identifier, RedshiftLexer.QuotedIdentifier]);
+// UnterminatedQuotedIdentifier is the dedicated recovery token this Postgres-lineage lexer emits
+// for a `"a` with no closing quote yet (mid-typing) — needed alongside the ordinary closed form.
+const REDSHIFT_NAME_TOKENS = new Set([
+    RedshiftLexer.Identifier,
+    RedshiftLexer.QuotedIdentifier,
+    RedshiftLexer.UnterminatedQuotedIdentifier,
+]);
 // ── Postgres / DuckDB (TVL-lineage forks like Redshift) ─────────────────────
 // The same rule split as Redshift applies (same grammar shapes): post-FROM → relation_expr,
 // SELECT/WHERE → a_expr; relation names are plain/quoted identifiers after FROM/JOIN.
@@ -101,12 +110,24 @@ const POSTGRES_TABLE_RULES = new Set([PostgresParser.RULE_relation_expr]);
 const POSTGRES_COLUMN_RULES = new Set([PostgresParser.RULE_a_expr]);
 const POSTGRES_PREFERRED = new Set([...POSTGRES_TABLE_RULES, ...POSTGRES_COLUMN_RULES]);
 const POSTGRES_RELATION_KEYWORDS = new Set([PostgresLexer.FROM, PostgresLexer.JOIN]);
-const POSTGRES_NAME_TOKENS = new Set([PostgresLexer.Identifier, PostgresLexer.QuotedIdentifier]);
+// UnterminatedQuotedIdentifier is the dedicated recovery token this lexer emits for a `"a` with no
+// closing quote yet (mid-typing) — needed alongside the ordinary closed form.
+const POSTGRES_NAME_TOKENS = new Set([
+    PostgresLexer.Identifier,
+    PostgresLexer.QuotedIdentifier,
+    PostgresLexer.UnterminatedQuotedIdentifier,
+]);
 const DUCKDB_TABLE_RULES = new Set([DuckdbParser.RULE_relation_expr]);
 const DUCKDB_COLUMN_RULES = new Set([DuckdbParser.RULE_a_expr]);
 const DUCKDB_PREFERRED = new Set([...DUCKDB_TABLE_RULES, ...DUCKDB_COLUMN_RULES]);
 const DUCKDB_RELATION_KEYWORDS = new Set([DuckdbLexer.FROM, DuckdbLexer.JOIN]);
-const DUCKDB_NAME_TOKENS = new Set([DuckdbLexer.Identifier, DuckdbLexer.QuotedIdentifier]);
+// UnterminatedQuotedIdentifier is the dedicated recovery token this Postgres-lineage lexer emits
+// for a `"a` with no closing quote yet (mid-typing) — needed alongside the ordinary closed form.
+const DUCKDB_NAME_TOKENS = new Set([
+    DuckdbLexer.Identifier,
+    DuckdbLexer.QuotedIdentifier,
+    DuckdbLexer.UnterminatedQuotedIdentifier,
+]);
 // -- Trino (first-party SqlBase.g4 split) ------------------------------------
 // Post-FROM relation names live under relationPrimary/qualifiedName; column slots are
 // primaryExpression. Identifiers: plain / "quoted" / backquoted / digit-led.

package/dist/databricks/behavior.js

@@ -2,7 +2,7 @@ import { acceptsFor } from "../dialect-behavior/coerce-rules.js";
 import { likePatternToRegExp } from "../scope/like-pattern.js";
 import { SIGNATURES } from "../signature/signatures.js";
 import { displayName, fold, foldTableName, matchesSourceKey, DATABRICKS_NAME_CONFIG } from "./fold.js";
-import { databricksLiteral, databricksParseType, DATABRICKS_FUNCTION_RETURNS } from "./infer.js";
+import { databricksLiteral, databricksParseType, databricksSpecial, DATABRICKS_FUNCTION_RETURNS } from "./infer.js";
 export const databricksBehavior = {
     fold,
     displayName,
@@ -14,6 +14,8 @@ export const databricksBehavior = {
     parseType: databricksParseType,
     functions: DATABRICKS_FUNCTION_RETURNS,
     division: "float",
+    dateSubtraction: "interval",
+    special: databricksSpecial,
     signatures: SIGNATURES.databricks,
     // Databricks implicit coercion: STRING containing a number coerces to numeric (STR_TO_NUM=true), no bool<->num (BOOL_NUM=false).
     accepts: (argType, paramText) => acceptsFor(databricksParseType, true, false, argType, paramText),

package/dist/databricks/infer.d.ts

@@ -1,5 +1,9 @@
 import { type FnRule } from "../infer/functions.js";
 import { type Type } from "../infer/types.js";
+import type { Expr } from "../ir/ir.js";
+export declare function databricksSpecial(fn: Extract<Expr, {
+    kind: "function";
+}>, typeOf: (e: Expr) => Type): Type | undefined;
 export declare const DATABRICKS_FUNCTION_RETURNS: Record<string, FnRule>;
 /** Databricks/Spark literal forms. */
 export declare function databricksLiteral(text: string): Type;