sqllens 1.1.0 → 1.2.0

package/dist/sqlite/behavior.d.ts

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

package/dist/sqlite/behavior.js

@@ -0,0 +1,19 @@
+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 { sqliteLiteral, sqliteParseType, SQLITE_FUNCTION_RETURNS } from "./infer.js";
+export const sqliteBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: sqliteLiteral,
+    parseType: sqliteParseType,
+    functions: SQLITE_FUNCTION_RETURNS,
+    division: "integer",
+    signatures: SIGNATURES.sqlite,
+    // SQLite implicit coercion: TEXT containing a number coerces to numeric (STR_TO_NUM=true), no bool<->num (BOOL_NUM=false).
+    accepts: (argType, paramText) => acceptsFor(sqliteParseType, true, false, argType, paramText),
+};

package/dist/sqlite/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const SQLITE_FOLD_RULE: FoldRule;
+/** Fold an identifier to its SQLite 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/sqlite/fold.js

@@ -0,0 +1,41 @@
+// SQLite 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).
+//
+// sqlite.org/lang_keywords.html — verified live: SQLite recognizes three identifier-quoting
+// delimiters, each documented only as "is an identifier" (double-quote, square-bracket, and
+// grave-accent/backtick forms) with no case-sensitivity distinction drawn between them or
+// against the unquoted form. SQLite's own grammar (IDENTIFIER token) treats `"x"`, `` `x` ``,
+// `[x]` and bare `x` as the same lexical category, and SQLite's C-level identifier compare
+// (sqlite3StrICmp) is ASCII case-insensitive regardless of how the name was spelled — the
+// documented quirk this module's brief calls out: unlike Postgres/Snowflake, quoting an
+// identifier does NOT make it case-sensitive in SQLite. So both unquoted AND quoted fold to
+// lower here (same shape as redshift/duckdb/trino). SQLite's own documented fold is
+// ASCII-only (it does not case-fold non-ASCII), but this module's shared applyCase uses JS
+// toLowerCase() — a Unicode-wide fold — so a rare non-ASCII identifier pair (Ä vs ä) that
+// SQLite would keep distinct conflates here: a known shared-engine limitation, consistent
+// across every dialect in this table. Bracket delimiters have no escape mechanism (the
+// lexer's `[`...`]` body is `~']'*` — no doubling), so a doubled `]]` inside `[...]` is not
+// unescaped, same as this module's tsql bracket handling.
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+const BACKTICK = ["`", "`"];
+export const SQLITE_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE, BACKTICK, ["[", "]"]],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its SQLite identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(SQLITE_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(SQLITE_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/sqlite/index.d.ts

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

package/dist/sqlite/index.js

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

package/dist/{infer/sqlite.d.ts → sqlite/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 SQLITE_ALIASES: Record<string, string>;
 export declare function sqliteParseType(text: string): Type;
 /** SQLite literal forms, by storage class (sqlite.org/datatype3.html has exactly five: NULL,

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

@@ -1,5 +1,6 @@
-import { commonType, widenSum } from "./coerce.js";
-import { parseType, scalar, UNKNOWN } from "./types.js";
+import { commonType, widenSum } from "../infer/coerce.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { fold } from "./fold.js";
 // ---------------------------------------------------------------------------
 // SQLite inference knowledge. Literal typing (A-R4) is storage-class-faithful (sqlite.org/
 // datatype3.html has exactly five: NULL/INTEGER/REAL/TEXT/BLOB — no native BOOLEAN or DATE/TIME/
@@ -19,7 +20,7 @@ import { parseType, scalar, UNKNOWN } from "./types.js";
 // ---------------------------------------------------------------------------
 export const SQLITE_ALIASES = {};
 export function sqliteParseType(text) {
-    return parseType(text, SQLITE_ALIASES, "sqlite");
+    return parseType(text, SQLITE_ALIASES, fold);
 }
 const S = scalar("string");
 const I = scalar("int");

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

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for sqlite: 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 SQLITE_SIGNATURES: Record<string, FnSignature[]>;

package/dist/sqlite/signatures.generated.js

@@ -0,0 +1,277 @@
+/** The merged function-signature table for sqlite: 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 const SQLITE_SIGNATURES = {
+    abs: [{ name: "abs", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/1.txt
+    acos: [{ name: "acos", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/1.txt
+    acosh: [{ name: "acosh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/2.txt
+    asin: [{ name: "asin", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/3.txt
+    asinh: [{ name: "asinh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/4.txt
+    atan: [{ name: "atan", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/5.txt
+    atan2: [{ name: "atan2", params: [{ name: "Y" }, { name: "X" }], origin: "harvested" }], // lang_mathfunc/6.txt
+    atanh: [{ name: "atanh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/7.txt
+    avg: [{ name: "avg", params: [{ name: "X" }], origin: "harvested" }], // lang_aggfunc/1.txt
+    ceil: [{ name: "ceil", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/8.txt
+    ceiling: [{ name: "ceiling", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/9.txt
+    changes: [{ name: "changes", params: [], origin: "harvested" }], // lang_corefunc/2.txt
+    coalesce: [{ name: "coalesce", params: [{ name: "X" }, { name: "Y" }], variadic: true, origin: "harvested" }], // lang_corefunc/4.txt
+    concat: [{ name: "concat", params: [{ name: "X" }], variadic: true, origin: "harvested" }], // lang_corefunc/5.txt
+    concat_ws: [{ name: "concat_ws", params: [{ name: "SEP" }, { name: "X" }], variadic: true, origin: "harvested" }], // lang_corefunc/6.txt
+    cos: [{ name: "cos", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/10.txt
+    cosh: [{ name: "cosh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/11.txt
+    count: [{ name: "count", params: [{ name: "X" }], origin: "harvested" }], // lang_aggfunc/3.txt
+    cume_dist: [{ name: "cume_dist", params: [], origin: "harvested" }], // windowfunctions/5.txt
+    date: [
+        {
+            name: "date",
+            params: [
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: date(time-value, modifier, ...)
+    datetime: [
+        {
+            name: "datetime",
+            params: [
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: datetime(time-value, modifier, ...)
+    degrees: [{ name: "degrees", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/12.txt
+    dense_rank: [{ name: "dense_rank", params: [], origin: "harvested" }], // windowfunctions/3.txt
+    exp: [{ name: "exp", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/13.txt
+    first_value: [{ name: "first_value", params: [{ name: "expr" }], origin: "harvested" }], // windowfunctions/13.txt
+    floor: [{ name: "floor", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/14.txt
+    format: [{ name: "format", params: [{ name: "FORMAT" }], variadic: true, origin: "harvested" }], // lang_corefunc/7.txt
+    glob: [
+        {
+            name: "glob",
+            params: [
+                { name: "pattern", type: "text" },
+                { name: "string", type: "text" },
+            ],
+            origin: "curated",
+        },
+    ], // curated: glob(X,Y) ("Y GLOB X")
+    group_concat: [
+        { name: "group_concat", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" },
+    ], // lang_aggfunc/5.txt
+    hex: [{ name: "hex", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/9.txt
+    if: [{ name: "if", params: [{ name: "B1" }, { name: "V1" }], variadic: true, origin: "harvested" }], // lang_corefunc/10.txt
+    ifnull: [{ name: "ifnull", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_corefunc/11.txt
+    iif: [
+        {
+            name: "iif",
+            params: [{ name: "condition", type: "boolean" }, { name: "true_value" }, { name: "false_value" }],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: iif(B1,V1,B2,V2,...,else)
+    instr: [{ name: "instr", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_corefunc/13.txt
+    json: [{ name: "json", params: [{ name: "X" }], origin: "harvested" }], // json1/1.txt
+    json_array_length: [
+        { name: "json_array_length", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" },
+    ], // json1/4.txt
+    json_each: [{ name: "json_each", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" }], // json1/20.txt
+    json_error_position: [{ name: "json_error_position", params: [{ name: "X" }], origin: "harvested" }], // json1/5.txt
+    json_extract: [
+        {
+            name: "json_extract",
+            params: [{ name: "X" }, { name: "P1" }, { name: "P2" }],
+            variadic: true,
+            origin: "harvested",
+        },
+    ], // json1/6.txt
+    json_group_array: [{ name: "json_group_array", params: [{ name: "X" }], origin: "harvested" }], // json1/14.txt
+    json_group_object: [
+        { name: "json_group_object", params: [{ name: "NAME" }, { name: "VALUE" }], origin: "harvested" },
+    ], // json1/15.txt
+    json_patch: [{ name: "json_patch", params: [{ name: "T" }, { name: "P" }], origin: "harvested" }], // json1/7.txt
+    json_quote: [{ name: "json_quote", params: [{ name: "X" }], origin: "harvested" }], // json1/13.txt
+    json_remove: [
+        {
+            name: "json_remove",
+            params: [{ name: "X" }, { name: "P", optional: true }],
+            variadic: true,
+            origin: "harvested",
+        },
+    ], // json1/8.txt
+    json_tree: [{ name: "json_tree", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" }], // json1/22.txt
+    json_type: [{ name: "json_type", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" }], // json1/11.txt
+    json_valid: [{ name: "json_valid", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // json1/12.txt
+    jsonb: [{ name: "jsonb", params: [{ name: "X" }], origin: "harvested" }], // json1/2.txt
+    jsonb_each: [{ name: "jsonb_each", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" }], // json1/21.txt
+    jsonb_tree: [{ name: "jsonb_tree", params: [{ name: "X" }, { name: "P", optional: true }], origin: "harvested" }], // json1/23.txt
+    julianday: [
+        {
+            name: "julianday",
+            params: [
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: julianday(time-value, modifier, ...)
+    lag: [
+        {
+            name: "lag",
+            params: [{ name: "expr" }, { name: "offset", optional: true }, { name: "default", optional: true }],
+            origin: "harvested",
+        },
+    ], // windowfunctions/9.txt
+    last_insert_rowid: [{ name: "last_insert_rowid", params: [], origin: "harvested" }], // lang_corefunc/14.txt
+    last_value: [{ name: "last_value", params: [{ name: "expr" }], origin: "harvested" }], // windowfunctions/14.txt
+    lead: [
+        {
+            name: "lead",
+            params: [{ name: "expr" }, { name: "offset", optional: true }, { name: "default", optional: true }],
+            origin: "harvested",
+        },
+    ], // windowfunctions/12.txt
+    length: [{ name: "length", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/15.txt
+    like: [
+        {
+            name: "like",
+            params: [
+                { name: "pattern", type: "text" },
+                { name: "string", type: "text" },
+                { name: "escape", type: "text", optional: true },
+            ],
+            origin: "curated",
+        },
+    ], // curated: like(X,Y[,Z]) ("Y LIKE X [ESCAPE Z]")
+    likelihood: [{ name: "likelihood", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_corefunc/18.txt
+    likely: [{ name: "likely", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/19.txt
+    ln: [{ name: "ln", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/15.txt
+    load_extension: [
+        { name: "load_extension", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" },
+    ], // lang_corefunc/21.txt
+    log: [
+        { name: "log", params: [{ name: "B" }, { name: "X" }], origin: "harvested" },
+        { name: "log", params: [{ name: "X" }], origin: "harvested" },
+    ], // lang_mathfunc/16.txt, lang_mathfunc/17.txt
+    log10: [{ name: "log10", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/18.txt
+    log2: [{ name: "log2", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/19.txt
+    lower: [{ name: "lower", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/22.txt
+    ltrim: [{ name: "ltrim", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" }], // lang_corefunc/24.txt
+    max: [{ name: "max", params: [{ name: "X" }, { name: "Y", optional: true }], variadic: true, origin: "harvested" }], // lang_corefunc/25.txt
+    median: [{ name: "median", params: [{ name: "X" }], origin: "harvested" }], // lang_aggfunc/7.txt
+    min: [{ name: "min", params: [{ name: "X" }, { name: "Y", optional: true }], variadic: true, origin: "harvested" }], // lang_corefunc/26.txt
+    mod: [{ name: "mod", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_mathfunc/20.txt
+    nth_value: [{ name: "nth_value", params: [{ name: "expr" }, { name: "N" }], origin: "harvested" }], // windowfunctions/15.txt
+    ntile: [{ name: "ntile", params: [{ name: "N" }], origin: "harvested" }], // windowfunctions/6.txt
+    nullif: [{ name: "nullif", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_corefunc/27.txt
+    octet_length: [{ name: "octet_length", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/28.txt
+    percent_rank: [{ name: "percent_rank", params: [], origin: "harvested" }], // windowfunctions/4.txt
+    percentile: [{ name: "percentile", params: [{ name: "Y" }, { name: "P" }], origin: "harvested" }], // lang_aggfunc/9.txt
+    percentile_cont: [{ name: "percentile_cont", params: [{ name: "Y" }, { name: "P" }], origin: "harvested" }], // lang_aggfunc/10.txt
+    percentile_disc: [{ name: "percentile_disc", params: [{ name: "Y" }, { name: "P" }], origin: "harvested" }], // lang_aggfunc/11.txt
+    pi: [{ name: "pi", params: [], origin: "harvested" }], // lang_mathfunc/21.txt
+    pow: [{ name: "pow", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_mathfunc/22.txt
+    power: [{ name: "power", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_mathfunc/23.txt
+    printf: [
+        {
+            name: "printf",
+            params: [{ name: "format", type: "text" }, { name: "args" }],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: printf(FORMAT,...) - alias for format()
+    quote: [{ name: "quote", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/30.txt
+    radians: [{ name: "radians", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/24.txt
+    random: [{ name: "random", params: [], origin: "harvested" }], // lang_corefunc/31.txt
+    randomblob: [{ name: "randomblob", params: [{ name: "N" }], origin: "harvested" }], // lang_corefunc/32.txt
+    rank: [{ name: "rank", params: [], origin: "harvested" }], // windowfunctions/2.txt
+    replace: [{ name: "replace", params: [{ name: "X" }, { name: "Y" }, { name: "Z" }], origin: "harvested" }], // lang_corefunc/33.txt
+    round: [{ name: "round", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" }], // lang_corefunc/35.txt
+    row_number: [{ name: "row_number", params: [], origin: "harvested" }], // windowfunctions/1.txt
+    rtrim: [{ name: "rtrim", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" }], // lang_corefunc/37.txt
+    sign: [{ name: "sign", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/38.txt
+    sin: [{ name: "sin", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/25.txt
+    sinh: [{ name: "sinh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/26.txt
+    soundex: [{ name: "soundex", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/39.txt
+    sqlite_compileoption_get: [{ name: "sqlite_compileoption_get", params: [{ name: "N" }], origin: "harvested" }], // lang_corefunc/40.txt
+    sqlite_compileoption_used: [{ name: "sqlite_compileoption_used", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/41.txt
+    sqlite_offset: [{ name: "sqlite_offset", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/42.txt
+    sqlite_source_id: [{ name: "sqlite_source_id", params: [], origin: "harvested" }], // lang_corefunc/43.txt
+    sqlite_version: [{ name: "sqlite_version", params: [], origin: "harvested" }], // lang_corefunc/44.txt
+    sqrt: [{ name: "sqrt", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/27.txt
+    strftime: [
+        {
+            name: "strftime",
+            params: [
+                { name: "format", type: "text" },
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: strftime(format, time-value, modifier, ...)
+    string_agg: [{ name: "string_agg", params: [{ name: "X" }, { name: "Y" }], origin: "harvested" }], // lang_aggfunc/12.txt
+    substr: [
+        { name: "substr", params: [{ name: "X" }, { name: "Y" }, { name: "Z", optional: true }], origin: "harvested" },
+    ], // lang_corefunc/46.txt
+    substring: [
+        {
+            name: "substring",
+            params: [{ name: "X" }, { name: "Y" }, { name: "Z", optional: true }],
+            origin: "harvested",
+        },
+    ], // lang_corefunc/48.txt
+    sum: [{ name: "sum", params: [{ name: "X" }], origin: "harvested" }], // lang_aggfunc/13.txt
+    tan: [{ name: "tan", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/28.txt
+    tanh: [{ name: "tanh", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/29.txt
+    time: [
+        {
+            name: "time",
+            params: [
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: time(time-value, modifier, ...)
+    timediff: [
+        {
+            name: "timediff",
+            params: [
+                { name: "time_value_1", type: "text" },
+                { name: "time_value_2", type: "text" },
+            ],
+            origin: "curated",
+        },
+    ], // curated: timediff(time-value-1, time-value-2)
+    total: [{ name: "total", params: [{ name: "X" }], origin: "harvested" }], // lang_aggfunc/14.txt
+    total_changes: [{ name: "total_changes", params: [], origin: "harvested" }], // lang_corefunc/49.txt
+    trim: [{ name: "trim", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" }], // lang_corefunc/51.txt
+    trunc: [{ name: "trunc", params: [{ name: "X" }], origin: "harvested" }], // lang_mathfunc/30.txt
+    typeof: [{ name: "typeof", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/52.txt
+    unhex: [{ name: "unhex", params: [{ name: "X" }, { name: "Y", optional: true }], origin: "harvested" }], // lang_corefunc/54.txt
+    unicode: [{ name: "unicode", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/55.txt
+    unistr: [{ name: "unistr", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/56.txt
+    unistr_quote: [{ name: "unistr_quote", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/57.txt
+    unixepoch: [
+        {
+            name: "unixepoch",
+            params: [
+                { name: "time_value", type: "text" },
+                { name: "modifier", type: "text" },
+            ],
+            variadic: true,
+            origin: "curated",
+        },
+    ], // curated: unixepoch(time-value, modifier, ...)
+    unlikely: [{ name: "unlikely", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/58.txt
+    upper: [{ name: "upper", params: [{ name: "X" }], origin: "harvested" }], // lang_corefunc/59.txt
+    zeroblob: [{ name: "zeroblob", params: [{ name: "N" }], origin: "harvested" }], // lang_corefunc/60.txt
+};

package/dist/symbols/symbols.js

@@ -1,4 +1,5 @@
-import { displayName, foldIdentifier } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { endPosition } from "../ir/span.js";
 import { inferType } from "../infer/infer.js";
 import { originsOf } from "../lineage/lineage.js";
@@ -39,7 +40,7 @@ function walk(scope, frame, out, schema, sourceSyms, expandStarOf) {
     // CTE declarations, and each CTE body as its own frame. The map key is the FOLDED identity;
     // the symbol (and frame label) shows the display form of the declared name.
     for (const [, cteRef] of scope.ctes) {
-        const name = displayName(cteRef.def.name, scope.dialect);
+        const name = behaviorOf(scope).displayName(cteRef.def.name);
         out.push({
             kind: "cte",
             modifiers: ["declaration"],
@@ -81,7 +82,7 @@ function walk(scope, frame, out, schema, sourceSyms, expandStarOf) {
         if (alias)
             out.push(alias);
         if (src.kind === "subquery") {
-            walk(src.scope, src.source.alias ? displayName(src.source.alias, scope.dialect) : "_subquery_", out, schema, sourceSyms, expandStarOf);
+            walk(src.scope, src.source.alias ? behaviorOf(scope).displayName(src.source.alias) : "_subquery_", out, schema, sourceSyms, expandStarOf);
             walked.add(src.scope);
         }
         else if (src.kind === "graphtable") {
@@ -219,12 +220,12 @@ function emitColumns(scope, frame, out, schema, sourceSyms, expandStarOf) {
             if (p.name === undefined)
                 continue;
             const last = p.expr.kind === "column" ? p.expr.parts[p.expr.parts.length - 1] : undefined;
-            const echo = last !== undefined && foldIdentifier(last, scope.dialect) === foldIdentifier(p.name, scope.dialect);
+            const echo = last !== undefined && behaviorOf(scope).fold(last) === behaviorOf(scope).fold(p.name);
             if (!echo) {
                 out.push({
                     kind: "column",
                     modifiers: ["declaration", "output"],
-                    name: displayName(p.name, scope.dialect),
+                    name: behaviorOf(scope).displayName(p.name),
                     span: spanOf(p.aliasCst ?? p.cst),
                     frame,
                     type: typeOrUndefined(inferType(p.expr, scope, schema)),
@@ -252,7 +253,7 @@ function emitColumns(scope, frame, out, schema, sourceSyms, expandStarOf) {
         out.push({
             kind: "column",
             modifiers,
-            name: ref.parts.map((p) => displayName(p, scope.dialect)).join("."),
+            name: ref.parts.map((p) => behaviorOf(scope).displayName(p)).join("."),
             span: spanOf(ref.cst),
             frame,
             definition: columnDefinition(res),
@@ -351,7 +352,7 @@ function aliasSymbol(src, frame, dialect) {
             ? {
                 kind: "alias",
                 modifiers: ["declaration"],
-                name: displayName(src.source.alias, dialect),
+                name: resolveBehavior(dialect).displayName(src.source.alias),
                 span: spanOf(src.source.aliasCst ?? src.source.cst),
                 frame,
             }
@@ -363,7 +364,7 @@ function aliasSymbol(src, frame, dialect) {
     return {
         kind: "alias",
         modifiers: ["declaration"],
-        name: displayName(s.alias, dialect),
+        name: resolveBehavior(dialect).displayName(s.alias),
         span: spanOf(s.aliasCst ?? s.cst),
         frame,
     };
@@ -388,20 +389,21 @@ function projectionSpan(scope, column, aliases) {
     if (scope.body.kind !== "select")
         return undefined;
     const projs = scope.body.projections;
-    const c = foldIdentifier(column, scope.dialect);
+    const b = behaviorOf(scope);
+    const c = b.fold(column);
     let p;
     if (aliases) {
-        const i = aliases.findIndex((a) => foldIdentifier(a, scope.dialect) === c);
+        const i = aliases.findIndex((a) => b.fold(a) === c);
         p = i >= 0 ? projs[i] : undefined;
     }
     else {
-        p = projs.find((pp) => pp.name !== undefined && foldIdentifier(pp.name, scope.dialect) === c);
+        p = projs.find((pp) => pp.name !== undefined && b.fold(pp.name) === c);
     }
     return p ? spanOf(p.aliasCst ?? p.cst) : undefined;
 }
 function relationSymbol(src, frame, dialect) {
     const ref = ["reference"];
-    const show = (n) => displayName(n, dialect);
+    const show = (n) => resolveBehavior(dialect).displayName(n);
     // The implicit pipe-stage relation is skipped by the caller; handled here only for exhaustiveness.
     if (src.kind === "relation") {
         return { kind: "subquery", modifiers: ref, name: "", span: spanOf(src.scope.body.cst), frame };

package/dist/trino/behavior.d.ts

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

package/dist/trino/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 { trinoLiteral, trinoParseType, TRINO_FUNCTION_RETURNS } from "./infer.js";
+// Trino implicit coercion: no VARCHAR<->numeric, no bool<->numeric — trino does NOT implicitly coerce.
+const STR_TO_NUM = false;
+const BOOL_NUM = false;
+export const trinoBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: trinoLiteral,
+    parseType: trinoParseType,
+    functions: TRINO_FUNCTION_RETURNS,
+    division: "integer",
+    signatures: SIGNATURES.trino,
+    accepts: (argType, paramText) => acceptsFor(trinoParseType, STR_TO_NUM, BOOL_NUM, argType, paramText),
+};

package/dist/trino/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const TRINO_FOLD_RULE: FoldRule;
+/** Fold an identifier to its Trino 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/trino/fold.js

@@ -0,0 +1,39 @@
+// Trino 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).
+// trino.io/docs/current/language/reserved.html — verified live: "Identifiers with other
+// characters must be delimited with double quotes (\"). ... Escape a \" with another preceding
+// double quote in a delimited identifier." and, blanket, "Identifiers are not treated as case
+// sensitive" — no quoted/unquoted distinction is drawn, and no backtick delimiter is documented
+// (adjusted from the originally proposed "backtick tolerated" — dropped, unconfirmed by the
+// live page). The fold DIRECTION (lower here) is this module's choice, not vendor-documented —
+// the live docs only commit to uniform case-insensitivity across quoted/unquoted, which lower-
+// folding both forms reproduces; chosen for consistency with the other case-insensitive-quoted
+// dialects (redshift/duckdb) and this module's undefined-dialect default. NOTE: Trino's own
+// engine source is internally inconsistent with this blanket docs claim — trino-parser's
+// Identifier.getCanonicalValue() canonicalizes unquoted to UPPER and preserves quoted verbatim
+// (ANSI-style, would make quoted case-sensitive), while trino-main's Field field-matching does
+// a blanket case-insensitive compare regardless of quoting. Encoding the documented behavior
+// per this module's citation policy; flagged as a discrepancy, not resolved against a live
+// engine.
+import { displayWith, foldWith } from "../ident/fold.js";
+const DOUBLE_QUOTE = ['"', '"'];
+export const TRINO_FOLD_RULE = {
+    delimiters: [DOUBLE_QUOTE],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its Trino identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(TRINO_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(TRINO_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/trino/index.d.ts

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

package/dist/trino/index.js

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

package/dist/{infer/trino.d.ts → trino/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 TRINO_ALIASES: Record<string, string>;
 export declare function trinoParseType(text: string): Type;
 /** Trino literal forms — language/types.html: integers are INTEGER/BIGINT by range (int here),

package/dist/{infer/trino.js → trino/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";
 // ---------------------------------------------------------------------------
 // Trino inference knowledge. Scalar-name aliases map Trino's type vocabulary onto the shared
 // canonical names (trino.io/docs/current/language/types.html); `/` on integers is INTEGER
@@ -29,7 +30,7 @@ export const TRINO_ALIASES = {
     tdigest: "binary",
 };
 export function trinoParseType(text) {
-    return parseType(text, TRINO_ALIASES, "trino");
+    return parseType(text, TRINO_ALIASES, fold);
 }
 const S = scalar("string");
 const I = scalar("int");