sqllens 1.6.0 → 1.7.0

package/dist/completion/complete.js

@@ -19,6 +19,7 @@ import { Token } from "antlr4ng";
 import { debugRethrow } from "../debug.js";
 import { nodeAt } from "../document/node-at.js";
 import { resolveBehavior } from "../dialect-behavior/registry.js";
+import { partSpanOf } from "../ir/part-span.js";
 import { DefaultTemplateProvider } from "../qualify/template-provider.js";
 import { callOf } from "../minijinja/apply-tags.js";
 import { sourcesMatchingQualifier } from "../scope/scope.js";
@@ -32,9 +33,9 @@ import { completionMeta } from "./parser-factory.js";
  * 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) {
+export function completeAt(doc, offset, schema, opts) {
     try {
-        return collect(doc, offset, schema);
+        return collect(doc, offset, schema, opts?.decorate);
     }
     catch (e) {
         // Total by contract: a walk/parse hiccup must not surface to the editor.
@@ -44,7 +45,7 @@ export function completeAt(doc, offset, schema) {
 }
 /** @deprecated Use completeAt — same function, uniform cursor-verb naming. */
 export const complete = completeAt;
-function collect(doc, offset, schema) {
+function collect(doc, offset, schema, decorate) {
     const dialect = doc.dialect;
     // Inside a jinja tag ({{ ref('| }}, {% if | %}, {{ a ~ | }}) the caret is not in SQL at all, so SQL
     // completion is wrong: the tag was blanked to a placeholder sitting in some SQL slot, so the walk
@@ -56,7 +57,7 @@ function collect(doc, offset, schema) {
     if (tags) {
         const slot = jinjaSlotAt(tags, doc.text, offset);
         if (slot)
-            return templateCompletions(slot, schema);
+            return templateCompletions(slot, schema, decorate);
         if (tags.some((t) => offset > t.tagSpan.start && offset < t.tagSpan.end))
             return [];
     }
@@ -89,18 +90,22 @@ function collect(doc, offset, schema) {
     const cand = collectCandidates(meta.atn, meta.entryRuleIndex, walkTokens, caretIdx, cfg.preferredRules, cfg.ignoredTokens);
     const out = [];
     const seen = new Set(); // dedup by `${kind}\0${label}`
-    const add = (c) => {
+    // Per-candidate structural identity (CandidateIdentity), keyed by the Completion object itself —
+    // consulted only when `decorate` is set (decorateResult, at the end of this function).
+    const identities = new Map();
+    const add = (c, identity) => {
         const key = `${c.kind}\0${c.label}`;
         if (seen.has(key))
             return;
         seen.add(key);
         out.push(c);
+        identities.set(c, identity);
     };
     // keywords — from candidate token types whose grammar literal is a word.
     for (const type of cand.tokens) {
         const label = keywordLabel(meta.vocabulary, type);
         if (label)
-            add({ label, kind: "keyword" });
+            add({ label, kind: "keyword" }, { kind: "keyword" });
     }
     // A RELATION PATH position (#38 stage 6): a dotted chain right before the caret whose anchor
     // token is FROM/JOIN-family (cfg.relationKeywordTokens — the same per-dialect set the
@@ -116,7 +121,7 @@ function collect(doc, offset, schema) {
     if (atRelationPath) {
         if (schema?.childrenOf) {
             for (const child of schema.childrenOf(path.parts, dialect))
-                add({ label: child.name, kind: child.kind });
+                add({ label: child.name, kind: child.kind }, { kind: child.kind });
         }
     }
     else if (path.parts.length > 0) {
@@ -126,41 +131,73 @@ function collect(doc, offset, schema) {
         // mid-edit the walk often reports nothing, but the dot chain itself is the member-position
         // evidence (it is the completion trigger character), and an unmatched qualifier answers [].
         const scoped = qualifiedSourceColumns(cellScopes, cellAst, cellOffset, path.parts, dialect, schema);
-        for (const c of scoped)
-            add(c);
+        for (const c of scoped.items)
+            add(c, { kind: "column", source: scoped.source });
         // Mid-edit the dangling dot often breaks the FROM parse and the scope is EMPTY — the same
         // 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) {
+        if (scoped.items.length === 0 && schema) {
             const fallback = qualifiedFallbackColumns(walkTokens, cfg, path.parts, schema, dialect, doc.templated?.tags, doc.text);
             for (const c of fallback)
-                add(c);
+                add(c, { kind: "column" });
         }
     }
     else {
         if (atTable) {
             // Bare relation slot: in-scope CTE names FIRST (they shadow same-named catalog tables),
             // then the catalog's tables.
-            for (const name of visibleCteNames(cellScopes, cellAst, cellOffset))
-                add({ label: name, kind: "cte" });
+            for (const cte of visibleCteNames(cellScopes, cellAst, cellOffset))
+                add({ label: cte.name, kind: "cte" }, { kind: "cte", declarationSpan: cte.declarationSpan });
             if (schema)
                 for (const t of schema.tables(dialect))
-                    add({ label: t, kind: "table" });
+                    add({ label: t, kind: "table" }, { kind: "table" });
         }
         // columns — value/column slot: the columns visible from the enclosing scope, plus a
         // broken-input fallback reading FROM/JOIN relation names straight off the token stream.
         if (atColumn) {
-            for (const c of visibleColumns(cellScopes, cellAst, dialect, cellOffset, schema))
-                add(c);
+            for (const { completion, source } of visibleColumns(cellScopes, cellAst, dialect, cellOffset, schema))
+                add(completion, { kind: "column", source });
             if (schema)
                 for (const c of fromRelationColumns(walkTokens, cfg, schema, dialect, doc.templated?.tags, doc.text))
-                    add(c);
+                    add(c, { kind: "column" });
             // functions — value/column slot: the dialect's inference-registry function names.
             for (const fn of Object.keys(resolveBehavior(dialect).functions))
-                add({ label: fn, kind: "function" });
+                add({ label: fn, kind: "function" }, { kind: "function" });
         }
     }
-    return pruneByPrefix(out, walkTokens, offset, cfg, doc.text, dialect);
+    const result = pruneByPrefix(out, walkTokens, offset, cfg, doc.text, dialect);
+    return decorate ? decorateResult(result, identities, decorate) : result;
+}
+/** Apply `decorate` to one candidate, merging its `detail`/`documentation` onto a COPY (the input is
+ *  never mutated). Total-safe: a throwing hook degrades to the undecorated candidate unchanged;
+ *  SQLLENS_DEBUG=1 rethrows (src/debug.ts), the same posture every other completeAt internal failure
+ *  gets. */
+function applyDecoration(candidate, identity, decorate) {
+    try {
+        const d = decorate(candidate, identity);
+        if (!d)
+            return candidate;
+        return {
+            ...candidate,
+            ...(d.detail !== undefined ? { detail: d.detail } : {}),
+            ...(d.documentation !== undefined ? { documentation: d.documentation } : {}),
+        };
+    }
+    catch (e) {
+        debugRethrow(e);
+        return candidate;
+    }
+}
+/** Decorate every candidate in the assembled SQL-slot result (post prefix-pruning — a pruned-out
+ *  candidate never reaches the consumer's hook), preserving `replaceRange` (Array.prototype.map
+ *  drops it — it is not an own array index). `identities` was populated by `add()` during collect();
+ *  a candidate somehow missing an entry (never happens in practice — every `add()` call site provides
+ *  one) falls back to its bare kind rather than crashing. */
+function decorateResult(result, identities, decorate) {
+    const decorated = result.map((c) => applyDecoration(c, identities.get(c) ?? { kind: c.kind }, decorate));
+    if (result.replaceRange)
+        decorated.replaceRange = result.replaceRange;
+    return decorated;
 }
 /** SQL identifier-quoting delimiters recognized across all ten dialects
  *  (docs/identifier-delimiter-contract.md) — used only to recognize a PARTIAL, possibly
@@ -252,15 +289,21 @@ function pruneByPrefix(out, toks, offset, cfg, text, dialect) {
  *  so this reads the `schema` when it is one (a DbtTemplateProvider IS a SchemaProvider, and the host
  *  already passes it here for column/table completion); the neutral provider offers none. A jinja slot
  *  with no candidates still returns [], never SQL keywords, so a caret inside a tag never leaks SQL
- *  completion. */
-function templateCompletions(slot, schema) {
+ *  completion. Every item's structural identity is `{ kind: "template", call: slot.call }` — the SAME
+ *  TemplateCall `templateCandidates` was asked with (a dbt model/source candidate resolves through
+ *  this call, so a `decorate` hook names it without re-parsing the call text). */
+function templateCompletions(slot, schema, decorate) {
     if (!(schema instanceof DefaultTemplateProvider))
         return [];
-    return schema.templateCandidates(slot.call, slot.argIndex).map((c) => ({
+    const items = schema.templateCandidates(slot.call, slot.argIndex).map((c) => ({
         label: c.label,
         kind: "template",
         ...(c.detail !== undefined ? { detail: c.detail } : {}),
     }));
+    if (!decorate)
+        return items;
+    const identity = { kind: "template", call: slot.call };
+    return items.map((c) => applyDecoration(c, identity, decorate));
 }
 /** The dotted qualifier immediately before the caret (#38): `analytics.` → ["analytics"],
  *  `analytics.sales.` → ["analytics","sales"], `analytics.sa|` (typing a segment) → ["analytics"].
@@ -294,13 +337,18 @@ function dottedPrefixAt(toks, caretIdx) {
     }
     return { parts, anchorIdx };
 }
-/** The CTE names visible from the caret's enclosing scope, as declared (display text). */
+/** The CTE names visible from the caret's enclosing scope, as declared (display text), each with its
+ *  declaration span (`CteDef.nameCst`, falling back to the whole `CteDef.cst`) — the same span
+ *  `SqlDocument.unionCtes` keys its own per-CTE aggregation on, so a `decorate` hook can pin "12
+ *  columns" to the right declaration even when a nested scope shadows the name. */
 function visibleCteNames(scopes, ast, offset) {
     const scope = enclosingScope(scopes, ast, offset);
     const out = [];
-    for (let s = scope; s; s = s.parent)
-        for (const cte of s.ctes.values())
-            out.push(cte.def.name);
+    for (let s = scope; s; s = s.parent) {
+        for (const cte of s.ctes.values()) {
+            out.push({ name: cte.def.name, declarationSpan: partSpanOf(cte.def.nameCst ?? cte.def.cst) });
+        }
+    }
     return out;
 }
 /** The walk's caret token index. Two rules, in order (anvil 2026-07-15; antlr4-c3's own caret
@@ -395,21 +443,27 @@ function fromRelationColumns(walkTokens, cfg, schema, dialect, tags, text) {
 /** The columns of the ONE source a dotted qualifier matches from the caret's scope (anvil item 2):
  *  `o.|` answers o's columns only. Matching is sourcesMatchingQualifier — the same validated,
  *  any-depth primitive column BINDING uses — walking enclosing scopes nearest-first. Ambiguous or
- *  unmatched qualifiers answer nothing (never a fabricated union). */
+ *  unmatched qualifiers answer nothing (never a fabricated union). `source` rides along (the matched
+ *  ResolvedSource, when exactly one matched) so the caller can attach it as the column candidates'
+ *  structural identity. */
 function qualifiedSourceColumns(scopes, ast, offset, qualParts, dialect, schema) {
     const scope = enclosingScope(scopes, ast, offset);
     if (!scope)
-        return [];
+        return { items: [] };
     const behavior = resolveBehavior(dialect);
     for (let s = scope; s; s = s.parent) {
         const matches = sourcesMatchingQualifier(s, qualParts);
         if (matches.length > 1)
-            return [];
+            return { items: [] };
         if (matches.length === 1) {
-            return columnsOf(matches[0], dialect, schema).map((c) => ({ ...c, label: behavior.displayName(c.label) }));
+            const source = matches[0];
+            return {
+                items: columnsOf(source, dialect, schema).map((c) => ({ ...c, label: behavior.displayName(c.label) })),
+                source,
+            };
         }
     }
-    return [];
+    return { items: [] };
 }
 /** 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
@@ -479,7 +533,8 @@ function qualifiedFallbackColumns(walkTokens, cfg, qualParts, schema, dialect, t
 }
 /** The columns visible from the scope enclosing `offset` (a CELL-relative offset into `scopes`).
  *  Derived sources / CTEs expose their own output column names; base-table sources get their columns
- *  (and types) from the schema. */
+ *  (and types) from the schema. Each item rides alongside the ResolvedSource it came from — the
+ *  column candidate's structural identity (a `decorate` hook's "source relation"). */
 function visibleColumns(scopes, ast, dialect, offset, schema) {
     const scope = enclosingScope(scopes, ast, offset);
     if (!scope)
@@ -494,7 +549,7 @@ function visibleColumns(scopes, ast, dialect, offset, schema) {
             if (seen.has(key))
                 continue;
             seen.add(key);
-            out.push({ ...col, label: behavior.displayName(col.label) });
+            out.push({ completion: { ...col, label: behavior.displayName(col.label) }, source: src });
         }
     }
     return out;

package/dist/databricks/infer.js

@@ -178,12 +178,14 @@ export const DATABRICKS_FUNCTION_RETURNS = {
         "date_format",
         "dayname",
         "monthname",
-        "string_agg",
-        "listagg",
         "to_json",
         "get_json_object",
         "string",
     ]),
+    // string_agg/listagg (sql-ref-functions listagg: "the datatype of the return is the same as the
+    // datatype of expr if expr is BINARY type, otherwise STRING" — v4.2.0 goldens: listagg(CAST(col
+    // AS BINARY)) -> binary, not string).
+    ...group((args) => (args[0]?.kind === "scalar" && args[0].name === "binary" ? BIN : S), ["string_agg", "listagg"]),
     ...group(fixed(I), [
         "ascii",
         "instr",
@@ -251,9 +253,21 @@ export const DATABRICKS_FUNCTION_RETURNS = {
         "bigint",
         "long",
     ]),
-    // avg — sql-ref: DECIMAL input stays DECIMAL, an interval stays its interval, else DOUBLE
-    // (v4.2.0 goldens: AVG over a decimal window column is decimal, not double).
-    ...group((args) => args[0]?.kind === "scalar" && (args[0].name === "decimal" || isIntervalName(args[0].name)) ? args[0] : D, ["avg", "try_avg", "mean"]),
+    // avg — sql-ref: DECIMAL input stays DECIMAL, an interval WIDENS to its family's full range
+    // (year-to-month / day-to-second — same fullInterval() promotion Multiply/DivideInterval already
+    // use; v4.2.0 goldens: avg(interval month) -> interval year to month, avg(interval day/second) ->
+    // interval day to second), else DOUBLE (v4.2.0 goldens: AVG over a decimal window column is
+    // decimal, not double).
+    ...group((args) => {
+        const a0 = args[0];
+        if (a0?.kind !== "scalar")
+            return D;
+        if (a0.name === "decimal")
+            return a0;
+        if (isIntervalName(a0.name))
+            return fullInterval(a0);
+        return D;
+    }, ["avg", "try_avg", "mean"]),
     ...group(fixed(D), [
         "sqrt",
         "cbrt",
@@ -341,6 +355,11 @@ export const DATABRICKS_FUNCTION_RETURNS = {
         "make_date",
         "next_day",
         "last_day",
+        // trunc(expr, unit) is DATE-truncation only (sql-ref-functions/trunc: "Returns date with the
+        // time portion of the day truncated..."; Databricks has no separate numeric-trunc overload,
+        // unlike Oracle/Postgres) — always DATE regardless of expr's own type (v4.2.0 goldens:
+        // trunc('2018-01-01', a) -> date, not the string argument's own type).
+        "trunc",
     ]),
     ...group(fixed(TS), [
         "current_timestamp",
@@ -374,7 +393,6 @@ export const DATABRICKS_FUNCTION_RETURNS = {
     ...group(firstArg, [
         "round",
         "bround",
-        "trunc",
         "mod",
         "pmod",
         "shiftleft",

package/dist/databricks/lower.js

@@ -1,7 +1,7 @@
 import { ParserRuleContext, TerminalNode } from "antlr4ng";
-import { ArithmeticBinaryContext, ArithmeticUnaryContext, CastByColonContext, CastContext, CollationForContext, ColumnReferenceContext, ComparisonContext, ConstantDefaultContext, CurrentLikeContext, DatabricksParser as P, DereferenceContext, ExistsContext, FunctionCallContext, IdentifierLiteralContext, LambdaContext, LogicalBinaryContext, LogicalNotContext, NamedParameterLiteralContext, ParenthesizedExpressionContext, PosParameterLiteralContext, PredicatedContext, PrimaryExpressionContext, RowConstructorContext, SearchedCaseContext, ShiftExpressionContext, SimpleCaseContext, StarContext, StringLiteralContext, SubqueryExpressionContext, SubscriptContext, TimestampaddContext, TimestampdiffContext, TryCastByColonContext, TypeAscriptionContext, } from "../generated/databricks/DatabricksParser.js";
+import { ArithmeticBinaryContext, ArithmeticUnaryContext, CastByColonContext, CastContext, CollationForContext, ColumnReferenceContext, ComparisonContext, ConstantDefaultContext, CreateVariableContext, CurrentLikeContext, DatabricksParser as P, DereferenceContext, ExistsContext, FunctionCallContext, IdentifierLiteralContext, LambdaContext, LogicalBinaryContext, LogicalNotContext, NamedParameterLiteralContext, ParenthesizedExpressionContext, PosParameterLiteralContext, PredicatedContext, PrimaryExpressionContext, RowConstructorContext, SearchedCaseContext, ShiftExpressionContext, SimpleCaseContext, StarContext, StringLiteralContext, SubqueryExpressionContext, SubscriptContext, TimestampaddContext, TimestampdiffContext, TryCastByColonContext, TypeAscriptionContext, } from "../generated/databricks/DatabricksParser.js";
 import { keywordCategory, swallowedCategories, swallowedStatements } from "../ir/statement.js";
-import { partSpansOf } from "../ir/part-span.js";
+import { partSpanOf, partSpansOf } from "../ir/part-span.js";
 import { freezeIR } from "../ir/freeze.js";
 import { qualifiedNameOf } from "../ir/qualified-name.js";
 import { DATABRICKS_NAME_CONFIG } from "./fold.js";
@@ -136,10 +136,23 @@ function lowerImpl(tree) {
         return flagged(tree, "other", swallowed > 0 ? "broken" : "empty");
     const stmt = elements[0] ?? tree; // the single element, or a legacy single-statement root
     const statement = statementCategory(stmt);
-    // A BEGIN…END scripting compound is a statement *sequence*, not a query — flag the
-    // whole thing rather than modelling whichever SELECT happens to come first inside it.
-    if (isCompound(stmt))
-        return flagged(stmt, statement, "compound");
+    // A BEGIN…END scripting compound is a statement *sequence*, not a query — flag the whole thing
+    // rather than modelling whichever SELECT happens to come first inside it, PLUS its own inner
+    // statements (applyCompoundFrame — the routine-frame slice's Databricks counterpart, see tsql's
+    // applyRoutineFrame / snowflake's applyScriptingFrame).
+    if (isCompound(stmt)) {
+        const q = flagged(stmt, statement, "compound");
+        applyCompoundFrame(q, stmt);
+        return q;
+    }
+    return lowerStatement(stmt);
+}
+/** Lower a single statement-shaped node into a QueryExpr: a real query gets its real body;
+ *  anything else gets the flagged "non-query" stub. Shared by lowerImpl's single-element case and
+ *  each compound inner statement whose own alternative is a nested `statement`
+ *  (lowerInnerCompoundStatement). */
+function lowerStatement(stmt) {
+    const statement = statementCategory(stmt);
     const query = firstOfRule(stmt, P.RULE_query);
     if (!query)
         return flagged(stmt, statement, "non-query");
@@ -148,12 +161,89 @@ function lowerImpl(tree) {
     return lowered;
 }
 /** A BEGIN…END scripting compound: the batch element's BEGIN-led alternative, or a legacy
- *  `singleCompoundStatement` root (other entries into this lowering still work). */
+ *  `singleCompoundStatement` root (other entries into this lowering still work). A NESTED
+ *  `beginEndCompoundBlock` inside another compound's own body is detected directly by
+ *  lowerInnerCompoundStatement instead (it is never routed through `statement`/lowerStatement, so
+ *  it never reaches this function). */
 function isCompound(stmt) {
     if (stmt.ruleIndex === P.RULE_multiStatementElement && stmt.start?.type === P.BEGIN)
         return true;
     return !!firstOfRule(stmt, P.RULE_singleCompoundStatement);
 }
+/** The `compoundBody` of a compound-shaped node: a direct child for the two shapes that carry one
+ *  right on themselves (a BEGIN-led `multiStatementElement`, or a nested `beginEndCompoundBlock`),
+ *  else a deep search for the legacy `singleCompoundStatement` root's own child. */
+function compoundBodyOf(stmt) {
+    const direct = directChildrenOfRule(stmt, P.RULE_compoundBody)[0];
+    if (direct)
+        return direct;
+    const single = firstOfRule(stmt, P.RULE_singleCompoundStatement);
+    return single ? directChildrenOfRule(single, P.RULE_compoundBody)[0] : undefined;
+}
+/** Layers a BEGIN...END scripting compound's inner statements (statements[]) onto the container's
+ *  existing flagged "compound" QueryExpr. Databricks' compoundBody has no variable-DECLARE
+ *  statement of its own (declareConditionStatement declares a named SQLSTATE handler condition, not
+ *  a typed variable — grammars/databricks/DatabricksParser.g4); the DECLARE-VARIABLE form
+ *  (`#createVariable`) is a plain `statement` alternative reachable from inside a compound body too,
+ *  so it rides that inner statement's own `declarations` (lowerInnerCompoundStatement) — there is no
+ *  container-level declarations counterpart here, unlike tsql/snowflake's signature-like preamble. */
+function applyCompoundFrame(q, stmt) {
+    const body = compoundBodyOf(stmt);
+    if (!body)
+        return;
+    const units = directChildrenOfRule(body, P.RULE_compoundStatement);
+    if (units.length)
+        q.statements = units.map(lowerInnerCompoundStatement);
+}
+/** One `compoundStatement` of a scripting body -> its own QueryExpr. A nested `beginEndCompoundBlock`
+ *  gets the same flagged "compound" stub + recursive statements[] (applyCompoundFrame called again,
+ *  so nesting layers naturally to any depth). A `statement` gets its real body via the shared
+ *  per-statement lowering (lowerStatement); its `#createVariable` alternative (DECLARE [OR REPLACE] [VARIABLE]
+ *  name [, name...] [data_type] [DEFAULT|= expr] — sql-ref-syntax-ddl-declare-variable) ALSO carries
+ *  its own `declarations`, mirroring a tsql body DECLARE / a Snowflake scripting LET: mid-body, not
+ *  container-level (rootDeclarations pools the whole tree regardless of nesting depth). Every other
+ *  scripting-only control-flow alternative (declareConditionStatement, setStatementInsideSqlScript,
+ *  declareHandlerStatement, ifElseStatement, caseStatement, whileStatement, repeatStatement,
+ *  leaveStatement, iterateStatement, loopStatement, forStatement) has no query body to lower — an
+ *  honest flagged "non-query" stub, categorised by leading keyword like the top-level grab-bag
+ *  commands. */
+function lowerInnerCompoundStatement(unit) {
+    const nested = directChildrenOfRule(unit, P.RULE_beginEndCompoundBlock)[0];
+    if (nested) {
+        const q = flagged(nested, "compound", "compound");
+        applyCompoundFrame(q, nested);
+        return q;
+    }
+    const stmt = directChildrenOfRule(unit, P.RULE_statement)[0];
+    if (stmt) {
+        const q = lowerStatement(stmt);
+        if (stmt instanceof CreateVariableContext)
+            q.declarations = lowerCreateVariable(stmt);
+        return q;
+    }
+    return flagged(unit, keywordCategory(unit.start?.text ?? ""), "non-query");
+}
+/** `DECLARE [OR REPLACE] [VARIABLE] name [, name...] [data_type] [{DEFAULT|=} expr]` (Databricks
+ *  session variables, sql-ref-syntax-ddl-declare-variable): ONE shared data_type/default expression
+ *  across every name in the list — duplicated onto EACH name's own VariableDecl, matching the doc's
+ *  own multi-name example (`DECLARE var1, var2 DOUBLE DEFAULT rand()`: both get type DOUBLE and
+ *  their own evaluation of the same expression). */
+function lowerCreateVariable(node) {
+    const dt = node.dataType();
+    const typeText = dt?.getText();
+    const defaultExpr = node.variableDefaultExpression();
+    const init = defaultExpr ? lowerExpression(defaultExpr.expression()) : undefined;
+    return node.identifierReference().map((idRef) => ({
+        name: idRef.getText(),
+        nameSpan: partSpanOf(idRef) ?? partSpanOf(node) ?? ZERO_PART_SPAN,
+        typeText,
+        init,
+        cst: idRef,
+    }));
+}
+/** A fallback span for the never-should-happen case a declared variable's own name token is missing
+ *  (a broken/partial parse): stays a valid `PartSpan` rather than `undefined`. */
+const ZERO_PART_SPAN = { start: 0, end: 0, line: 0, column: 0, endLine: 0, endColumn: 0 };
 /**
  * The statement category, from the parse — not the source text. Spark's `statement` rule labels its
  * alternatives, so the structural cases are exact: a `#dmlStatement` (`ctes? dmlStatementNoWith`) is
@@ -207,7 +297,8 @@ function lowerQuery(query) {
     if (orderBy && body.kind !== "pipe")
         for (const o of orderBy)
             columnsOf(o, body.columns, "orderBy");
-    return { kind: "query", ctes, body, orderBy, cst: query };
+    const limit = extractLimit(query);
+    return { kind: "query", ctes, body, orderBy, limit, cst: query };
 }
 /** The ORDER BY sort expressions from the query's queryOrganization (not SORT/CLUSTER/DISTRIBUTE BY). */
 function extractOrderBy(query) {
@@ -238,6 +329,48 @@ function extractOrderBy(query) {
     }
     return items.length ? items : undefined;
 }
+/** The LIMIT / OFFSET row-limiting clause from the query's queryOrganization (grammar:
+ *  `(LIMIT (ALL | expression))? (OFFSET expression)?`) — learn.microsoft.com/en-us/azure/databricks/
+ *  sql/language-manual/sql-ref-syntax-qry-select-limit. `LIMIT ALL` is Spark's documented no-cap
+ *  spelling (no row-count expression to carry); recorded as a present-but-unbounded clause, the
+ *  same convention as postgres' extractLimit's `LIMIT ALL` handling. */
+function extractLimit(query) {
+    const qo = directChildrenOfRule(query, P.RULE_queryOrganization)[0];
+    if (!qo)
+        return undefined;
+    const info = {};
+    let any = false;
+    let afterLimit = false;
+    let afterOffset = false;
+    for (let i = 0; i < qo.getChildCount(); i++) {
+        const child = qo.getChild(i);
+        if (!(child instanceof ParserRuleContext)) {
+            const t = child?.symbol?.type;
+            if (t === P.LIMIT) {
+                any = true;
+                afterLimit = true;
+            }
+            else if (t === P.ALL) {
+                afterLimit = false; // LIMIT ALL — no row cap; recorded as present-but-unbounded
+            }
+            else if (t === P.OFFSET) {
+                any = true;
+                afterOffset = true;
+                afterLimit = false;
+            }
+            continue;
+        }
+        if (afterLimit && child.ruleIndex === P.RULE_expression) {
+            info.top = lowerExpression(child);
+            afterLimit = false;
+        }
+        else if (afterOffset && child.ruleIndex === P.RULE_expression) {
+            info.offset = lowerExpression(child);
+            afterOffset = false;
+        }
+    }
+    return any ? info : undefined;
+}
 /** A queryTerm is a pipe (`queryTerm |> rhs`), a set operation (two queryTerm branches), or a select. */
 function lowerQueryTerm(queryTerm) {
     // Pipe (Spark 4.0 `|>`): the queryTerm left-recurses — `((base |> op1) |> op2)`. Unwind the left
@@ -1690,7 +1823,11 @@ function topRelationPrimaries(node) {
     return out;
 }
 function buildSource(relationPrimary) {
-    const tableAlias = directChildrenOfRule(relationPrimary, P.RULE_tableAlias)[0];
+    // `VALUES (...), (...) AS alias(cols)` as a relationPrimary (#inlineTableDefault2) nests its own
+    // tableAlias INSIDE the inlineTable node, one level below relationPrimary's direct children.
+    const inlineTable = firstOfRule(relationPrimary, P.RULE_inlineTable);
+    const tableAlias = directChildrenOfRule(relationPrimary, P.RULE_tableAlias)[0] ??
+        (inlineTable ? directChildrenOfRule(inlineTable, P.RULE_tableAlias)[0] : undefined);
     const aliasCst = tableAlias ? firstOfRule(tableAlias, P.RULE_strictIdentifier) : undefined;
     const alias = aliasCst?.getText();
     const columnAliases = tableAlias ? columnAliasList(tableAlias) : undefined;
@@ -1706,6 +1843,21 @@ function buildSource(relationPrimary) {
             cst: relationPrimary,
         };
     }
+    // An inline table constructor used as a FROM-clause relation: lower its rows the same way as a
+    // top-level VALUES query body (buildInlineTable already names each projection from the alias's
+    // own column list) and expose the result as a subquery source, so `SELECT *` expands against ITS
+    // OWN named projections (schema-free) instead of falling into the generic multipartIdentifier
+    // branch below — which has nothing to read here and previously produced an anonymous EMPTY-named
+    // "table" source that any real schema misses as unknown-table (Spark-goldens gate, 2026-07-21).
+    if (inlineTable) {
+        return {
+            kind: "subquery",
+            query: { kind: "query", ctes: [], body: buildInlineTable(inlineTable), cst: inlineTable },
+            alias,
+            aliasCst,
+            cst: relationPrimary,
+        };
+    }
     const multipart = firstOfRule(relationPrimary, P.RULE_multipartIdentifier);
     const partNodes = multipart ? directChildrenOfRule(multipart, P.RULE_errorCapturingIdentifier) : [];
     const parts = partNodes.length ? partNodes.map((p) => p.getText()) : multipart ? [multipart.getText()] : [];

package/dist/databricks/reserved.generated.d.ts

@@ -0,0 +1,2 @@
+import type { KeywordReservation } from "../dialect-symbols.js";
+export declare const DATABRICKS_RESERVED: Record<string, KeywordReservation>;