sqllens 1.0.0 → 1.2.0

package/dist/derived-dialects.js

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// Derived-dialect → dialect map. The eight grammars parse more than eight
+// Derived-dialect → dialect map. The grammars parse more than their own named
 // engines: a *derived dialect* is an engine with no grammar of its own whose
 // SQL surface is a subset of — or identical to — one we already parse (Amazon
 // Athena's engine is Trino, AWS Glue runs Spark, Microsoft Fabric / Azure
@@ -20,6 +20,8 @@ export const DERIVED_DIALECTS = {
     postgres: "postgres",
     duckdb: "duckdb",
     trino: "trino",
+    sqlite: "sqlite",
+    mysql: "mysql",
     // our dialect name (not an engine name) — accepted so both vocabularies work
     tsql: "tsql",
     // Spark SQL family — Databricks SQL = Spark SQL; AWS Glue runs Spark
@@ -34,6 +36,22 @@ export const DERIVED_DIALECTS = {
     // is Trino's predecessor
     athena: "trino",
     presto: "trino",
+    // MariaDB — forked from MySQL 5.1 and still a near-superset for ordinary DQL/DML, so mapped to
+    // the mysql grammar as a PARTIAL derived alias (Open Gap, not full coverage — MariaDB's own
+    // extensions are unmodeled). B-R5.5 spot-checked four MariaDB-specific statements against the
+    // mysql/Positive-Technologies grammar (grammars/mysql/) by actually parsing them
+    // (temp_auto/mariadb-probe.mts, parseMysql()): all four FAIL —
+    //   `SELECT NEXT VALUE FOR seq_name` (mariadb.com/docs/.../sequences/next-value) — "no viable
+    //     alternative" (no NEXT/VALUE/FOR sequence-expression production);
+    //   `DELETE FROM t WHERE id = 1 RETURNING *` (mariadb.com/docs/.../delete) — "mismatched input
+    //     'RETURNING'" (no RETURNING clause on DELETE; MySQL itself has none either);
+    //   `INSERT INTO t (a) VALUES (1) RETURNING *` (mariadb.com/docs/.../insert) — "extraneous input
+    //     '*'", same missing-RETURNING gap;
+    //   `CREATE SEQUENCE seq_name START WITH 1 INCREMENT BY 1` (mariadb.com/docs/.../sequences/
+    //     create-sequence) — "no viable alternative" (no CREATE SEQUENCE DDL in this grammar).
+    // A plain `SELECT a, b FROM t WHERE a = 1` control probe parses with 0 errors, confirming
+    // ordinary DQL still works — the alias covers that surface, not MariaDB's own additions.
+    mariadb: "mysql",
     // Alternate spelling of the engine name (alias class, same as our own dialect
     // names above). Admitted 2026-07-10 on the anvil channel's request; caveat noted
     // there: no dbt adapter is attested to emit `postgresql` as its adapter_type —

package/dist/dialect-behavior/behavior.d.ts

@@ -0,0 +1,26 @@
+import type { IdentKind } from "../ident/fold.js";
+import type { FnRule } from "../infer/functions.js";
+import type { Type } from "../infer/types.js";
+import type { Expr } from "../ir/ir.js";
+import type { FnSignature } from "../signature/signatures.js";
+export interface DialectBehavior {
+    fold(raw: string, kind?: IdentKind): string;
+    displayName(raw: string): string;
+    foldTableName(parts: string[]): string[];
+    matchesSourceKey(key: string, rawPart: string): boolean;
+    likeMatch(pattern: string, name: string): boolean;
+    literal(text: string): Type;
+    parseType(text: string): Type;
+    functions: Record<string, FnRule>;
+    division: "float" | "integer" | "decimal";
+    special?(fn: Extract<Expr, {
+        kind: "function";
+    }>): Type | undefined;
+    /** The dialect's merged function-signature table (curated overrides folded over the harvested
+     *  long tail at generation time — src/<dialect>/signatures.generated.ts). Each name maps to an
+     *  ordered overload SET, not a single shape. The arity checker trusts every overload regardless of
+     *  origin; operand-type checking trusts a name with exactly one overload of "curated" origin only. */
+    signatures: Record<string, readonly FnSignature[]>;
+    /** Whether an argument type is acceptable for a declared param (dialect implicit-coercion rules). */
+    accepts(argType: Type, paramText: string | undefined): boolean;
+}

package/dist/dialect-behavior/behavior.js

@@ -0,0 +1 @@
+export {};

package/dist/dialect-behavior/carrier.d.ts

@@ -0,0 +1,5 @@
+import type { DialectBehavior } from "./behavior.js";
+/** The dialect behavior for a scope (or anything carrying a `.dialect` tag). */
+export declare function behaviorOf(carrier: {
+    dialect?: string;
+}): DialectBehavior;

package/dist/dialect-behavior/carrier.js

@@ -0,0 +1,5 @@
+import { resolveBehavior } from "./registry.js";
+/** The dialect behavior for a scope (or anything carrying a `.dialect` tag). */
+export function behaviorOf(carrier) {
+    return resolveBehavior(carrier.dialect);
+}

package/dist/dialect-behavior/coerce-rules.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from "../infer/types.js";
+export declare const IMPLICIT_STR_TO_NUM: ReadonlySet<string>;
+export declare const IMPLICIT_BOOL_NUM: ReadonlySet<string>;
+/** Whether `argType` is acceptable for a declared param whose type text is `paramText`. `parseType`
+ *  parses that text with the dialect's rules; `strToNum`/`boolNum` are the dialect's implicit-coercion
+ *  flags (IMPLICIT_STR_TO_NUM / IMPLICIT_BOOL_NUM membership). Pure engine, takes no dialect. */
+export declare function acceptsFor(parseType: (text: string) => Type, strToNum: boolean, boolNum: boolean, argType: Type, paramText: string | undefined): boolean;

package/dist/dialect-behavior/coerce-rules.js

@@ -0,0 +1,69 @@
+const NUMERIC = new Set(["tinyint", "smallint", "int", "bigint", "float", "double", "decimal"]);
+const TEMPORAL = new Set(["date", "timestamp", "time", "interval"]);
+function familyOf(name) {
+    if (NUMERIC.has(name))
+        return "num";
+    if (name === "string")
+        return "str";
+    if (name === "boolean")
+        return "bool";
+    if (TEMPORAL.has(name))
+        return "temporal";
+    if (name === "binary")
+        return "binary";
+    return "other";
+}
+// Dialects that implicitly bridge STRING to numeric in a function argument, so a str->num mismatch must
+// NOT be flagged. Doc-cited per dialect:
+//  - databricks: implicit crosscasting casts STRING to the expected numeric type
+//    (docs.databricks.com/sql/language-manual/sql-ref-datatype-rules);
+//  - tsql: char/varchar to int/decimal is an implicit conversion in the CAST/CONVERT chart
+//    (learn.microsoft.com/sql/t-sql/functions/cast-and-convert-transact-sql);
+//  - snowflake: VARCHAR containing a number coerces to NUMBER
+//    (docs.snowflake.com/en/sql-reference/data-type-conversion);
+//  - redshift: PG-8.0 lineage keeps pre-8.3 implicit text to numeric casts
+//    (docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html);
+//  - postgres / duckdb: a quoted constant is initially UNKNOWN and coerces to whatever the call needs
+//    (postgresql.org/docs/18 sql-syntax-lexical 4.1.2.1), but our inference types every quoted literal
+//    as `string`, so rejecting would false-fire on valid SQL;
+//  - sqlite: TEXT/NUMERIC type affinity coerces a TEXT value against a numeric argument
+//    (sqlite.org/datatype3.html "Type Affinity");
+//  - mysql: numeric context converts a string operand to a number automatically
+//    (dev.mysql.com/doc/refman/8.4/en/type-conversion.html).
+// NOT in the set (rejection stays live, corpus-proven): bigquery, trino.
+export const IMPLICIT_STR_TO_NUM = new Set([
+    "databricks",
+    "tsql",
+    "snowflake",
+    "redshift",
+    "postgres",
+    "duckdb",
+    "sqlite",
+    "mysql",
+]);
+// Dialects that implicitly bridge boolean to/from numeric. tsql: `bit` (aliased to boolean) converts
+// to/from int per the CAST/CONVERT chart. mysql: BOOL/BOOLEAN is a documented TINYINT(1) synonym
+// (dev.mysql.com/doc/refman/8.4/en/numeric-type-syntax.html) and a comparison result is 1/0/NULL,
+// assignable anywhere an integer is expected. Everywhere else bool<->num rejection is corpus-proven safe;
+// sqlite is left out (TRUE/FALSE are literal aliases for 1/0 and SQLITE_ALIASES has no bool key, so this
+// checker never sees a boolean-typed sqlite argument from a declared column).
+export const IMPLICIT_BOOL_NUM = new Set(["tsql", "mysql"]);
+/** Whether `argType` is acceptable for a declared param whose type text is `paramText`. `parseType`
+ *  parses that text with the dialect's rules; `strToNum`/`boolNum` are the dialect's implicit-coercion
+ *  flags (IMPLICIT_STR_TO_NUM / IMPLICIT_BOOL_NUM membership). Pure engine, takes no dialect. */
+export function acceptsFor(parseType, strToNum, boolNum, argType, paramText) {
+    if (!paramText)
+        return true; // untyped param -> no information, accept
+    const param = parseType(paramText);
+    if (param.kind !== "scalar" || argType.kind !== "scalar")
+        return true; // complex/unknown -> accept
+    const fa = familyOf(argType.name);
+    const fp = familyOf(param.name);
+    if (fa === fp)
+        return true; // same family -> accept
+    if (fa === "str" && fp === "num")
+        return strToNum;
+    if ((fa === "bool" && fp === "num") || (fa === "num" && fp === "bool"))
+        return boolNum;
+    return true; // every other cross-family pair accepts
+}

package/dist/dialect-behavior/public-fold.d.ts

@@ -0,0 +1,6 @@
+import type { IdentKind } from "../ident/fold.js";
+export type { IdentKind };
+/** Fold an identifier to its identity key under the dialect's rules. */
+export declare function foldIdentifier(raw: string, dialect: string | undefined, kind?: IdentKind): string;
+/** Presentation twin: strip delimiters, no case change. Never use for comparison. */
+export declare function displayName(raw: string, dialect: string | undefined): string;

package/dist/dialect-behavior/public-fold.js

@@ -0,0 +1,9 @@
+import { resolveBehavior } from "./registry.js";
+/** Fold an identifier to its identity key under the dialect's rules. */
+export function foldIdentifier(raw, dialect, kind = "other") {
+    return resolveBehavior(dialect).fold(raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. Never use for comparison. */
+export function displayName(raw, dialect) {
+    return resolveBehavior(dialect).displayName(raw);
+}

package/dist/dialect-behavior/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Dialect } from "../dialect.js";
+import type { DialectBehavior } from "./behavior.js";
+export declare const BEHAVIORS: Record<Dialect, DialectBehavior>;
+/** Resolve a dialect string (the IR/Scope tag) to its behavior. Throws on an unregistered/absent
+ *  dialect — sqllens applies NO default; the consumer must supply a supported Dialect. */
+export declare function resolveBehavior(name: string | undefined): DialectBehavior;

package/dist/dialect-behavior/registry.js

@@ -0,0 +1,34 @@
+import { databricksBehavior } from "../databricks/behavior.js";
+import { tsqlBehavior } from "../tsql/behavior.js";
+import { snowflakeBehavior } from "../snowflake/behavior.js";
+import { bigqueryBehavior } from "../bigquery/behavior.js";
+import { redshiftBehavior } from "../redshift/behavior.js";
+import { postgresBehavior } from "../postgres/behavior.js";
+import { duckdbBehavior } from "../duckdb/behavior.js";
+import { trinoBehavior } from "../trino/behavior.js";
+import { sqliteBehavior } from "../sqlite/behavior.js";
+import { mysqlBehavior } from "../mysql/behavior.js";
+export const BEHAVIORS = {
+    databricks: databricksBehavior,
+    tsql: tsqlBehavior,
+    snowflake: snowflakeBehavior,
+    bigquery: bigqueryBehavior,
+    redshift: redshiftBehavior,
+    postgres: postgresBehavior,
+    duckdb: duckdbBehavior,
+    trino: trinoBehavior,
+    sqlite: sqliteBehavior,
+    mysql: mysqlBehavior,
+};
+/** Resolve a dialect string (the IR/Scope tag) to its behavior. Throws on an unregistered/absent
+ *  dialect — sqllens applies NO default; the consumer must supply a supported Dialect. */
+export function resolveBehavior(name) {
+    // Object.hasOwn guards against inherited keys ("constructor", "toString", …) resolving to a
+    // prototype member instead of throwing.
+    const b = name !== undefined && Object.hasOwn(BEHAVIORS, name)
+        ? BEHAVIORS[name]
+        : undefined;
+    if (!b)
+        throw new Error(`sqllens: no behavior for dialect "${name}" — supply a supported Dialect.`);
+    return b;
+}

package/dist/dialect-symbols.js

@@ -12,11 +12,10 @@
 // Sources, per set:
 //
 // - functions: the union of (a) the dialect's type-inference registry keys
-//   (src/infer/dialect.ts `inferDialect(dialect).functions`), (b) the curated
-//   per-dialect signature table (src/signature/signatures.ts FUNCTION_SIGNATURES),
-//   (c) its harvested long-tail counterpart (HARVESTED_SIGNATURES — populated for
-//   T-SQL only on this branch, the rest map to `{}` per that file's own header), and
-//   (d) for databricks only, the Spark higher-order function names
+//   (src/infer/dialect.ts `inferDialect(dialect).functions`), (b) the dialect's
+//   merged function-signature table (src/signature/signatures.ts SIGNATURES,
+//   built by tools/harvest-signatures.mjs from curated overrides folded over the
+//   harvested long tail), and (c) for databricks only, the Spark higher-order function names
 //   (src/infer/infer.ts HOF_LAMBDA_ARG: transform/zip_with/aggregate/reduce/
 //   transform_keys/transform_values). Those six are genuine Spark builtins
 //   (spark.apache.org/docs/latest/api/sql/#aggregate) that never get a FnRule registry
@@ -75,16 +74,20 @@ import { RedshiftLexer } from "./generated/redshift/RedshiftLexer.js";
 import { PostgresLexer } from "./generated/postgres/PostgresLexer.js";
 import { DuckdbLexer } from "./generated/duckdb/DuckdbLexer.js";
 import { TrinoLexer } from "./generated/trino/TrinoLexer.js";
-import { inferDialect } from "./infer/dialect.js";
+import { SqliteLexer } from "./generated/sqlite/SqliteLexer.js";
+import { MysqlLexer } from "./generated/mysql/MysqlLexer.js";
+import { resolveBehavior } from "./dialect-behavior/registry.js";
 import { HOF_LAMBDA_ARG } from "./infer/infer.js";
 import { SCALAR_ALIASES, TSQL_ALIASES } from "./infer/types.js";
-import { SNOWFLAKE_ALIASES } from "./infer/snowflake.js";
-import { BQ_ALIASES } from "./infer/bigquery.js";
-import { REDSHIFT_ALIASES } from "./infer/redshift.js";
-import { POSTGRES_ALIASES } from "./infer/postgres.js";
-import { DUCKDB_ALIASES } from "./infer/duckdb.js";
-import { TRINO_ALIASES } from "./infer/trino.js";
-import { FUNCTION_SIGNATURES, HARVESTED_SIGNATURES } from "./signature/signatures.js";
+import { SNOWFLAKE_ALIASES } from "./snowflake/infer.js";
+import { BQ_ALIASES } from "./bigquery/infer.js";
+import { REDSHIFT_ALIASES } from "./redshift/infer.js";
+import { POSTGRES_ALIASES } from "./postgres/infer.js";
+import { DUCKDB_ALIASES } from "./duckdb/infer.js";
+import { TRINO_ALIASES } from "./trino/infer.js";
+import { SQLITE_ALIASES } from "./sqlite/infer.js";
+import { MYSQL_ALIASES } from "./mysql/infer.js";
+import { SIGNATURES } from "./signature/signatures.js";
 // bigquery's generated lexer class is GoogleSQLLexer (the fork is Bytebase's GoogleSQL grammar).
 const LEXERS = {
     databricks: () => new DatabricksLexer(CharStream.fromString("")),
@@ -95,6 +98,8 @@ const LEXERS = {
     postgres: () => new PostgresLexer(CharStream.fromString("")),
     duckdb: () => new DuckdbLexer(CharStream.fromString("")),
     trino: () => new TrinoLexer(CharStream.fromString("")),
+    sqlite: () => new SqliteLexer(CharStream.fromString("")),
+    mysql: () => new MysqlLexer(CharStream.fromString("")),
 };
 // The scalar-type-alias table per dialect (see module header, `types` set). Databricks has no
 // dedicated table — dialect.ts's `parseType` falls back to types.ts's default (SCALAR_ALIASES).
@@ -107,6 +112,8 @@ const TYPE_ALIASES = {
     postgres: POSTGRES_ALIASES,
     duckdb: DUCKDB_ALIASES,
     trino: TRINO_ALIASES,
+    sqlite: SQLITE_ALIASES,
+    mysql: MYSQL_ALIASES,
 };
 /** A bare, keyword-shaped literal token text: letters/digits/underscore, starting with a
  *  letter or underscore. Filters out punctuation (`'('`, `','`) and operator (`'<>'`, `'::'`)
@@ -128,11 +135,9 @@ function keywordsFor(dialect) {
 }
 function functionsFor(dialect) {
     const out = new Set();
-    for (const name of Object.keys(inferDialect(dialect).functions))
+    for (const name of Object.keys(resolveBehavior(dialect).functions))
         out.add(name.toUpperCase());
-    for (const name of Object.keys(FUNCTION_SIGNATURES[dialect]))
-        out.add(name.toUpperCase());
-    for (const name of Object.keys(HARVESTED_SIGNATURES[dialect]))
+    for (const name of Object.keys(SIGNATURES[dialect]))
         out.add(name.toUpperCase());
     if (dialect === "databricks") {
         for (const name of Object.keys(HOF_LAMBDA_ARG))

package/dist/dialect.d.ts

@@ -1,3 +1,3 @@
 /** The dialects reachable through the unified surface. Each has its own grammar/CST and a
- *  parse+lower pair; everything after lower() runs unchanged on all eight. */
-export type Dialect = "databricks" | "tsql" | "snowflake" | "bigquery" | "redshift" | "postgres" | "duckdb" | "trino";
+ *  parse+lower pair; everything after lower() runs unchanged on all of them. */
+export type Dialect = "databricks" | "tsql" | "snowflake" | "bigquery" | "redshift" | "postgres" | "duckdb" | "trino" | "sqlite" | "mysql";

package/dist/document/document.d.ts

@@ -190,7 +190,7 @@ export declare class SqlDocument {
      *  comes from the CELL owning `offset` (with a cell-relative offset), so a node in statement 2 of a
      *  multi-cell document resolves through its own scope tree — NOT the compound facade. The returned
      *  `expr.cst` carries CELL-relative spans; a caller turning it into a document Range shifts it by the
-     *  owning cell's start (see `cellBaseAt` in src/lsp/ranges.ts). Single-cell: identical to today. */
+     *  owning cell's start. Single-cell: identical to today. */
     nodeAt(offset: number): NodeHit | undefined;
     /** The declaration + every occurrence of the symbol at `offset` (the references engine,
      *  cell-aware): resolved over the CELL owning the offset — its own scopes/ast, with a

package/dist/document/document.js

@@ -35,7 +35,8 @@ import { referencesAt as referencesAtScopes } from "../references/references.js"
 import { freezeIR } from "../ir/freeze.js";
 import { partSpanOf, starSpanOf } from "../ir/part-span.js";
 import { OPEN_PROVIDER } from "../qualify/template-provider.js";
-import { foldIdentifier } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { LineIndex } from "./line-index.js";
 import { nodeAt } from "./node-at.js";
 import { splitStatements } from "./split.js";
@@ -346,7 +347,7 @@ export class SqlDocument {
      *  comes from the CELL owning `offset` (with a cell-relative offset), so a node in statement 2 of a
      *  multi-cell document resolves through its own scope tree — NOT the compound facade. The returned
      *  `expr.cst` carries CELL-relative spans; a caller turning it into a document Range shifts it by the
-     *  owning cell's start (see `cellBaseAt` in src/lsp/ranges.ts). Single-cell: identical to today. */
+     *  owning cell's start. Single-cell: identical to today. */
     nodeAt(offset) {
         const cell = this.cellAt(offset);
         if (!cell)
@@ -617,7 +618,7 @@ export class SqlDocument {
                 const declarationSpan = partSpanOf(cteRef.def.nameCst ?? cteRef.def.cst);
                 if (!declarationSpan)
                     continue; // no real token to key on — never fabricate a span
-                const name = foldIdentifier(cteRef.def.name, doc.dialect);
+                const name = resolveBehavior(doc.dialect).fold(cteRef.def.name);
                 const key = `${name}:${declarationSpan.start}`;
                 let entry = byKey.get(key);
                 if (!entry) {
@@ -756,12 +757,12 @@ function scopeOutputColumns(scope, qualification) {
                 // zero-width convention (that exists so expanded Syms are never cursor hit-test
                 // targets; these pairs are name/position enumeration, where a real span is useful).
                 for (const pair of pairs)
-                    out.push({ name: foldIdentifier(pair.name, scope.dialect), raw: pair.name, span });
+                    out.push({ name: behaviorOf(scope).fold(pair.name), raw: pair.name, span });
             }
             else if (p.name !== undefined) {
                 const span = partSpanOf(p.aliasCst ?? p.cst);
                 if (span)
-                    out.push({ name: foldIdentifier(p.name, scope.dialect), raw: p.name, span });
+                    out.push({ name: behaviorOf(scope).fold(p.name), raw: p.name, span });
             }
             // else: anonymous expression — no determinable name, skip
         }
@@ -784,14 +785,14 @@ function scopeOutputColumns(scope, qualification) {
         const declared = new Map();
         for (const branch of [scope.branches.left, scope.branches.right]) {
             for (const col of scopeOutputColumns(branch, qualification)) {
-                const key = foldIdentifier(col.raw, scope.dialect);
+                const key = behaviorOf(scope).fold(col.raw);
                 if (!declared.has(key))
                     declared.set(key, col);
             }
         }
         const out = [];
         for (const name of names) {
-            const hit = declared.get(foldIdentifier(name, scope.dialect));
+            const hit = declared.get(behaviorOf(scope).fold(name));
             if (hit)
                 out.push(hit); // a name no branch declares a span for is skipped, never fabricated
         }

package/dist/duckdb/behavior.d.ts

@@ -0,0 +1,2 @@
+import type { DialectBehavior } from "../dialect-behavior/behavior.js";
+export declare const duckdbBehavior: DialectBehavior;

package/dist/duckdb/behavior.js

@@ -0,0 +1,21 @@
+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 } from "./fold.js";
+import { duckdbLiteral, duckdbParseType, DUCKDB_FUNCTION_RETURNS } from "./infer.js";
+// DuckDB implicit coercion: a quoted constant is initially UNKNOWN and coerces to whatever the call
+// needs (str->num), no bool<->num.
+// STR_TO_NUM=true, BOOL_NUM=false
+export const duckdbBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: duckdbLiteral,
+    parseType: duckdbParseType,
+    functions: DUCKDB_FUNCTION_RETURNS,
+    division: "float",
+    signatures: SIGNATURES.duckdb,
+    accepts: (argType, paramText) => acceptsFor(duckdbParseType, true, false, argType, paramText),
+};

package/dist/duckdb/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const DUCKDB_FOLD_RULE: FoldRule;
+/** Fold an identifier to its DuckDB identity key. */
+export declare function fold(raw: string, kind?: IdentKind): string;
+/** Presentation twin: strip delimiters, no case change. */
+export declare function displayName(raw: string): string;
+export declare function foldTableName(parts: string[]): string[];
+export declare function matchesSourceKey(key: string, rawPart: string): boolean;

package/dist/duckdb/fold.js

@@ -0,0 +1,29 @@
+// DuckDB identifier folding. The FoldRule plus its bound engine, colocated here because BOTH the
+// upstream lower() and the downstream DialectBehavior need it (the fold rule is the one dialect concern
+// used at two stages).
+// 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."
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+export const DUCKDB_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its DuckDB identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(DUCKDB_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(DUCKDB_FOLD_RULE, raw);
+}
+export function foldTableName(parts) {
+    return parts.map((p) => fold(p, "table"));
+}
+export function matchesSourceKey(key, rawPart) {
+    return key === fold(rawPart) || key === fold(rawPart, "table");
+}

package/dist/duckdb/index.d.ts

@@ -0,0 +1,7 @@
+import { lower } from "./lower.js";
+import { parseDuckdb } from "./parse.js";
+export declare const duckdb: {
+    parse: typeof parseDuckdb;
+    lower: typeof lower;
+    behavior: import("../dialect-behavior/behavior.js").DialectBehavior;
+};

package/dist/duckdb/index.js

@@ -0,0 +1,10 @@
+// The complete duckdb dialect module: parse + lower (front end) and behavior (semantic knowledge).
+// The registry wires this; to understand everything sqllens does for duckdb, read this folder.
+import { duckdbBehavior } from "./behavior.js";
+import { lower } from "./lower.js";
+import { parseDuckdb } from "./parse.js";
+export const duckdb = {
+    parse: parseDuckdb,
+    lower,
+    behavior: duckdbBehavior,
+};

package/dist/{infer/duckdb.d.ts → duckdb/infer.d.ts}

@@ -1,5 +1,5 @@
-import { type Type } from "./types.js";
-import type { FnRule } from "./functions.js";
+import { type Type } from "../infer/types.js";
+import type { FnRule } from "../infer/functions.js";
 export declare const DUCKDB_ALIASES: Record<string, string>;
 export declare function duckdbParseType(text: string): Type;
 /** DuckDB literal forms — sql/data_types/literal_types.md: integers without a decimal point are

package/dist/{infer/duckdb.js → duckdb/infer.js}

@@ -1,5 +1,6 @@
-import { parseType, scalar, UNKNOWN } from "./types.js";
-import { commonType } from "./coerce.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { commonType } from "../infer/coerce.js";
+import { fold } from "./fold.js";
 // ---------------------------------------------------------------------------
 // DuckDB inference knowledge. Scalar-name aliases map DuckDB's type vocabulary
 // onto the shared canonical names (duckdb.org/docs/current/sql/data_types/
@@ -48,7 +49,7 @@ export const DUCKDB_ALIASES = {
     json: "json",
 };
 export function duckdbParseType(text) {
-    return parseType(text, DUCKDB_ALIASES, "duckdb");
+    return parseType(text, DUCKDB_ALIASES, fold);
 }
 const S = scalar("string");
 const I = scalar("int");

package/dist/duckdb/lower.js

@@ -3,7 +3,7 @@ import { DuckdbParser as P } from "../generated/duckdb/DuckdbParser.js";
 import { keywordCategory, swallowedCategories, swallowedStatements } from "../ir/statement.js";
 import { partSpansOf } from "../ir/part-span.js";
 import { freezeIR } from "../ir/freeze.js";
-import { displayName } from "../ident/fold.js";
+import { displayName } from "./fold.js";
 // ---------------------------------------------------------------------------
 // Lowering — DuckDB (fork of this repo's grammars/postgres pair, TVL lineage)
 // CST -> the shared dialect-neutral IR (src/ir/ir.ts). The semantic layer runs
@@ -14,8 +14,8 @@ import { displayName } from "../ident/fold.js";
 // QUALIFY, GROUP BY ALL, star EXCLUDE/REPLACE/RENAME + COLUMNS(), prefix
 // aliases (x: 42, alias: tbl), list/struct/map literals + comprehensions,
 // `lambda x:` lambdas, method chaining (x.f(y) → f(x, y)), string-literal
-// relations (FROM 'file.parquet'), and the PIVOT/UNPIVOT statements (flagged
-// `pivot`/`unpivot` — visible gaps, not silent drops).
+// relations (FROM 'file.parquet'), and the PIVOT/UNPIVOT statements (modelled
+// onto the shared PivotInfo/UnpivotInfo; the statement PIVOT is `dynamic`).
 // ---------------------------------------------------------------------------
 // https://duckdb.org/docs/current/sql/functions/aggregates.html — general + approximate +
 // statistical + ordered-set aggregate names (holistic/nested families included).
@@ -259,10 +259,15 @@ function nonQuery(cst, reason) {
         cst,
     };
 }
-/** PIVOT/UNPIVOT statement — keep the source relation + ON/USING column refs visible, flag the
- *  reshape as unsupported (duckdb.org/docs/current/sql/statements/pivot.md, unpivot.md). */
+/** PIVOT/UNPIVOT statement — modelled onto the shared PivotInfo/UnpivotInfo IR, the same shapes the
+ *  sibling dialects produce (duckdb.org/docs/current/sql/statements/pivot.md, unpivot.md).
+ *
+ *  PIVOT `⟨rel⟩ ON ⟨cols⟩ USING ⟨aggs⟩ [GROUP BY ⟨rows⟩]`: the distinct ON-values become output columns,
+ *  so the output is data-dependent — modelled as a `dynamic` PivotInfo (structure captured; output
+ *  resolves to unknown, never a wrong set). UNPIVOT `⟨rel⟩ ON ⟨cols⟩ [INTO NAME ⟨n⟩ VALUE ⟨v⟩]` is a
+ *  static reshape (passthrough minus the ON columns, plus the name/value columns), modelled exactly. */
 function lowerPivotStmt(stmt) {
-    const kind = stmt.ruleIndex === P.RULE_pivotstmt ? "pivot" : "unpivot";
+    const isPivot = stmt.ruleIndex === P.RULE_pivotstmt;
     const from = [];
     const qn = directChildrenOfRule(stmt, P.RULE_qualified_name)[0];
     if (qn)
@@ -273,13 +278,39 @@ function lowerPivotStmt(stmt) {
         from.push({ kind: "subquery", query: inner ? lowerSelectStmt(inner) : emptyQuery(sw), cst: sw });
     }
     const columns = [];
-    for (const on of [
-        ...collectOfRule(stmt, P.RULE_pivot_on),
-        ...collectOfRule(stmt, P.RULE_unpivot_on),
-        ...collectOfRule(stmt, P.RULE_target_el),
-    ]) {
-        for (const a of directChildrenOfRule(on, P.RULE_a_expr))
-            columnsOf(lowerExpr(a), columns, "projection");
+    // Column names referenced by a clause's a_expr children, recorded into `columns` for lineage.
+    const colNames = (clauseRule, clause) => {
+        const names = [];
+        for (const node of collectOfRule(stmt, clauseRule))
+            for (const a of directChildrenOfRule(node, P.RULE_a_expr)) {
+                const refs = [];
+                columnsOf(lowerExpr(a), refs, clause);
+                for (const r of refs) {
+                    columns.push(r);
+                    names.push(r.parts[r.parts.length - 1]);
+                }
+            }
+        return names;
+    };
+    let pivot;
+    let unpivot;
+    if (isPivot) {
+        const forColumns = colNames(P.RULE_pivot_on, "projection"); // ON columns → the pivot key
+        const aggColumns = colNames(P.RULE_target_el, "projection"); // USING aggregate arguments
+        colNames(P.RULE_group_by_list, "groupBy"); // GROUP BY dims → referenced, kept visible for lineage
+        pivot = { values: [], forColumns, aggColumns, dynamic: true };
+    }
+    else {
+        const removed = colNames(P.RULE_unpivot_on, "projection"); // ON columns consumed into rows
+        // INTO NAME ⟨colid⟩ VALUE ⟨name_list⟩; default DuckDB column names are "name"/"value".
+        const nameColumn = directChildrenOfRule(stmt, P.RULE_colid)[0];
+        const valueList = directChildrenOfRule(stmt, P.RULE_name_list)[0];
+        const valueName = valueList ? collectOfRule(valueList, P.RULE_name)[0] : undefined;
+        unpivot = {
+            valueColumn: valueName ? textOf(valueName) : "value",
+            nameColumn: nameColumn ? textOf(nameColumn) : "name",
+            removed,
+        };
     }
     const body = {
         kind: "select",
@@ -287,7 +318,8 @@ function lowerPivotStmt(stmt) {
         from,
         columns,
         aggregated: false,
-        unsupported: [kind],
+        pivot,
+        unpivot,
         cst: stmt,
     };
     return { kind: "query", ctes: [], body, cst: stmt };
@@ -1356,7 +1388,7 @@ function lowerFuncExpr(node) {
     const fname = directChildrenOfRule(app, P.RULE_func_name)[0] ??
         directChildrenOfRule(app, P.RULE_plain_func_name)[0] ??
         directChildrenOfRule(app, P.RULE_dotted_func_name)[0];
-    const name = (fname ? displayName(lastName(fname), "duckdb") : (leftmostToken(app) ?? "")).toLowerCase();
+    const name = (fname ? displayName(lastName(fname)) : (leftmostToken(app) ?? "")).toLowerCase();
     const args = funcArgs(app);
     const within = directChildrenOfRule(node, P.RULE_within_group_clause)[0];
     if (within) {

package/dist/duckdb/signatures.generated.d.ts

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for duckdb: curated overrides folded over the harvested
+ *  doc-derived long tail (overrides win by key, replacing the whole overload set), keyed by
+ *  lowercased name. Each name maps to an ORDERED overload set - a name with one documented shape
+ *  is a one-element array. `origin` says which layer produced the set. */
+export declare const DUCKDB_SIGNATURES: Record<string, FnSignature[]>;