sqllens 1.2.0 → 1.4.0

package/dist/duckdb/fold.js

@@ -4,14 +4,16 @@
 // duckdb.org/docs/current/sql/dialect/keywords_and_identifiers.html — verified live: "Identifiers
 // in DuckDB are always case-insensitive, similarly to PostgreSQL. However, unlike PostgreSQL...
 // DuckDB also treats quoted identifiers as case-insensitive" — quoting only preserves the
-// identifier for DISPLAY, not identity. Doubled-quote escape: "Double quotes can be escaped by
-// repeating the quote character."
+// identifier for DISPLAY, not identity. The insensitivity is ASCII-scoped, same page (#22):
+// "Case-insensitivity is implemented using an ASCII-based comparison: col_A and col_a are equal
+// but col_á is not equal to them"; hence ascii-lower for both forms. Doubled-quote escape:
+// "Double quotes can be escaped by repeating the quote character."
 import { displayWith, foldWith } from "../ident/fold.js";
 const DOUBLE_QUOTE = ['"', '"'];
 export const DUCKDB_FOLD_RULE = {
     delimiters: [DOUBLE_QUOTE],
-    unquoted: "lower",
-    quoted: "lower",
+    unquoted: "ascii-lower",
+    quoted: "ascii-lower",
 };
 /** Fold an identifier to its DuckDB identity key. */
 export function fold(raw, kind = "other") {

package/dist/ident/fold.d.ts

@@ -1,12 +1,15 @@
 /** "table" = a table/view identifier — only BigQuery treats these differently from everything
  *  else (columns, aliases, CTE names, struct/field names, …), which is "other". */
 export type IdentKind = "table" | "other";
-type CaseFold = "lower" | "upper" | "preserve";
+/** "ascii-lower" folds [A-Z] only, passing every other character through, for dialects whose
+ *  engines compare identifiers ASCII-case-insensitively (sqlite, postgres, duckdb, redshift):
+ *  there `Ä` and `ä` are DISTINCT identifiers, and a Unicode-wide fold would conflate them (#22). */
+type CaseFold = "lower" | "upper" | "preserve" | "ascii-lower";
 export interface FoldRule {
     /** [open, close] delimiter pairs this dialect recognizes, tried in order. */
     delimiters: readonly (readonly [string, string])[];
     /** Case fold applied to an unquoted identifier. */
-    unquoted: "lower" | "upper";
+    unquoted: "lower" | "upper" | "ascii-lower";
     /** Case fold applied to a quoted (delimited) identifier. */
     quoted: CaseFold;
     /** BigQuery only: table identifiers preserve case whether or not they're backtick-quoted —

package/dist/ident/fold.js

@@ -12,6 +12,8 @@ function applyCase(text, fold) {
         return text.toLowerCase();
     if (fold === "upper")
         return text.toUpperCase();
+    if (fold === "ascii-lower")
+        return text.replace(/[A-Z]/g, (c) => c.toLowerCase());
     return text;
 }
 /** Strip one matching delimiter pair off `raw` (if present) and unescape its body.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, type Nullability, Lineage, originsOfExpr, lineageAt, lineageOf, type LineageHop, type ViaStep, tokenize, SqlDocument, LineIndex, complete, completeAt, type Completion, jinjaSlotAt, type JinjaSlot, signatureAt, SIGNATURES, lookupSignature, hasSignature, referencesAt, type Occurrence, type Occurrences, dialectSymbols, type DialectSymbols, CallbackSchema, type SchemaProvider, type TableResolver, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, type IdentKind, type SignatureHelpInfo, type SignatureLabel, type FnSignature, type ParamSig, type Dialect, type DialectOpts, type ParseResultIR, type Analysis, type Token, type TokenRole, type DocumentAnalysis, type StatementCell, type StatementCellSpan, type DocumentVariant, type UnionCte, } from "./api.js";
+export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, type Nullability, Lineage, originsOfExpr, lineageAt, lineageOf, type LineageHop, type ViaStep, tokenize, SqlDocument, LineIndex, complete, completeAt, type Completion, jinjaSlotAt, type JinjaSlot, signatureAt, SIGNATURES, lookupSignature, hasSignature, renderSignature, FN_DOCS, lookupFnDoc, referencesAt, type Occurrence, type Occurrences, dialectSymbols, type DialectSymbols, CallbackSchema, type SchemaProvider, type TableResolver, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, type IdentKind, type SignatureHelpInfo, type SignatureLabel, type FnSignature, type ParamSig, type RenderSignatureOptions, type FnDoc, type Dialect, type DialectOpts, type ParseResultIR, type Analysis, type Token, type TokenRole, type DocumentAnalysis, type StatementCell, type StatementCellSpan, type DocumentVariant, type UnionCte, } from "./api.js";
 export { SqlSession, type SessionOptions } from "./session.js";
 export { parseDatabricks } from "./databricks/parse.js";
 export { parseTSql } from "./tsql/parse.js";

package/dist/index.js

@@ -10,7 +10,7 @@
 //   - Building blocks: the per-dialect parse*/lower and the raw shared passes, for callers who
 //                 want a specific tier or the raw CST escape hatch.
 // --- Uniform entry, lift helpers, typed wrappers, composable passes (src/api.ts) ---
-export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, Lineage, originsOfExpr, lineageAt, lineageOf, tokenize, SqlDocument, LineIndex, complete, completeAt, jinjaSlotAt, signatureAt, SIGNATURES, lookupSignature, hasSignature, referencesAt, dialectSymbols, CallbackSchema, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, } from "./api.js";
+export { parse, analyze, toAst, toScopes, qualify, lineage, deriveSymbols, TypeInfo, Lineage, originsOfExpr, lineageAt, lineageOf, tokenize, SqlDocument, LineIndex, complete, completeAt, jinjaSlotAt, signatureAt, SIGNATURES, lookupSignature, hasSignature, renderSignature, FN_DOCS, lookupFnDoc, referencesAt, dialectSymbols, CallbackSchema, DERIVED_DIALECTS, resolveDialect, foldIdentifier, displayName, } from "./api.js";
 // SqlSession — the verb-shaped facade over one SqlDocument (offset in, answer out; pure delegation).
 export { SqlSession } from "./session.js";
 // --- Per-dialect building blocks: parse* (CST + errors) and lower* (CST → IR), kept as one

package/dist/infer/types.js

@@ -44,7 +44,10 @@ export function parseType(text, aliases = SCALAR_ALIASES, foldField) {
             const raw = part.slice(0, colon).trim();
             const name = foldField ? foldField(raw) : raw;
             if (name) {
-                fields.push({ name, type: parseType(stripComment(part.slice(colon + 1).trim()), undefined, foldField) });
+                fields.push({
+                    name,
+                    type: parseType(stripComment(part.slice(colon + 1).trim()), undefined, foldField),
+                });
             }
         }
         return { kind: "struct", fields };

package/dist/minijinja/apply-tags.js

@@ -17,8 +17,9 @@
 // TemplateProvider for a call's relation (`provider.relationOf`) and carries no ref/source vocabulary
 // itself. The NEUTRAL provider answers nothing, so a bare parse leaves calls opaque; a
 // DbtTemplateProvider names ref/source. Naming is never-wrong: a resolved name comes from the call's
-// literal args, and a call whose relation the provider does not resolve keeps its placeholder name and
-// stays opaque. We NEVER fabricate a name.
+// literal args, and a call whose relation the provider does not resolve takes the RAW TAG TEXT as its
+// name ({{ ref('m') }} verbatim) and stays opaque. We NEVER fabricate a name — in particular the
+// placeholder fill (scaffolding this library invented) never escapes as one (issue #35).
 //
 // The IR is frozen after lower(); this transform REBUILDS with STRUCTURAL SHARING (new objects only on
 // changed paths, an unchanged subtree keeps its original already-frozen reference) and re-freezes the
@@ -152,7 +153,10 @@ function markTemplateExprs(node, ctx) {
 // never wrong.
 // ---------------------------------------------------------------------------
 /** Match a direct string-literal argument's raw text (no escapes, one token). */
-const LITERAL_ARG = /^(['"])([^'"\\]*)\1$/;
+/** A literal argument's value: a quoted string (quote-stripped) or a bare numeric literal —
+ *  both are the user's own text, never computed. Everything else stays `null` (computed). */
+const LITERAL_ARG = /^(?:(['"])([^'"\\]*)\1|(-?\d+(?:\.\d+)?))$/;
+const literalValueOf = (m) => m[2] ?? m[3];
 /** The raw text of a span. */
 function sliceSpan(text, span) {
     return text.slice(span.start, span.end);
@@ -172,11 +176,11 @@ export function callOf(mc, text) {
         const kw = KWARG_RE.exec(raw);
         if (kw) {
             const m = LITERAL_ARG.exec(kw[2].trim());
-            kwargs.push({ name: kw[1], value: m ? m[2] : null });
+            kwargs.push({ name: kw[1], value: m ? literalValueOf(m) : null });
         }
         else {
             const m = LITERAL_ARG.exec(raw);
-            args.push(m ? m[2] : null);
+            args.push(m ? literalValueOf(m) : null);
         }
     }
     return {
@@ -398,6 +402,11 @@ function transformTableSource(src, ctx) {
     // where `jjj…` was a fabrication.
     const aliasTok = src.aliasCst?.start;
     const base = aliasTok != null && inSpan(aliasTok.start, tag.tagSpan) ? withoutAlias(src) : src;
+    // An unresolved source's name is the RAW TAG TEXT — the bytes the user actually wrote. The
+    // placeholder fill is scaffolding this library invented so the grammar parses; letting it
+    // escape as a relation name (scope sources, lineage dependencies, go-to-def) is fabrication
+    // under the never-wrong rule (issue #35, reported by anvil).
+    const rawTagName = [ctx.text.slice(tag.tagSpan.start, tag.tagSpan.end)];
     // NOTE: `template.span` intentionally aliases `tag.tagSpan` BY REFERENCE. freezeIR
     // therefore also freezes the TagNode.tagSpan object returned in `.tags`, benign
     // since spans are read-only. Every call marker carries its `call`, the provider key
@@ -406,24 +415,24 @@ function transformTableSource(src, ctx) {
         const call = callOf(tag, ctx.text);
         const rel = ctx.provider.relationOf(call);
         // A call in a FROM slot (ref/source/a TVF-like macro). When the provider resolves its
-        // relation, carry the resolved name; otherwise keep the placeholder name (never fabricated).
+        // relation, carry the resolved name; otherwise the raw tag text (never the fill).
         // Either way the `call` keeps it consultable, so an unresolved call is not a dead end: a
         // provider added later resolves it. ref vs source is not stored here, it is call.name.
-        const named = rel ? { ...base, name: [...rel.nameParts] } : base;
+        const named = { ...base, name: rel ? [...rel.nameParts] : rawTagName };
         const template = { kind: "call", span: tag.tagSpan, call };
         return attach(ctx, { ...named, template }, tag);
     }
     // Non-call expression tag (var / env_var / other) in a FROM slot. A bare `{{ t }}` resolving
     // through a `{% set t = … %}` single-call RHS carries the resolved relation name (when the
     // provider resolved it) or the call identity alone; every other case gets the opaque "expr"
-    // marker, so the placeholder name stops posing as a real table.
+    // marker. In every unresolved case the name is the raw tag text, never the fill.
     const ident = tag.kind === "other" ? bareIdentOf(tag, ctx.text) : undefined;
     const resolved = ident !== undefined ? ctx.sets.get(ident) : undefined;
     if (resolved) {
-        const named = resolved.name ? { ...base, name: [...resolved.name] } : base;
+        const named = { ...base, name: resolved.name ? [...resolved.name] : rawTagName };
         const template = { kind: "call", span: tag.tagSpan, indirect: true, call: resolved.call };
         return attach(ctx, { ...named, template }, tag);
     }
     const template = { kind: "expr", span: tag.tagSpan, opaque: true };
-    return attach(ctx, { ...base, template }, tag);
+    return attach(ctx, { ...base, name: rawTagName, template }, tag);
 }

package/dist/mysql/fn-docs.generated.d.ts

@@ -0,0 +1,2 @@
+import type { FnDoc } from "../signature/docs.js";
+export declare const MYSQL_FN_DOCS: Record<string, FnDoc>;