sqllens 1.0.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/sqlite/infer.d.ts

@@ -0,0 +1,12 @@
+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,
+ *  INTEGER, REAL, TEXT, BLOB — there is no native BOOLEAN or DATE/TIME/TIMESTAMP class).
+ *  TRUE/FALSE are literal aliases for the integers 1/0, not a boolean type
+ *  (sqlite.org/lang_expr.html#literal_values_constants_). CURRENT_TIME/CURRENT_DATE/
+ *  CURRENT_TIMESTAMP expand to a formatted TEXT value (sqlite.org/lang_createtable.html
+ *  §"The DEFAULT clause"), not a date/time type. */
+export declare function sqliteLiteral(text: string): Type;
+export declare const SQLITE_FUNCTION_RETURNS: Record<string, FnRule>;

package/dist/sqlite/infer.js

@@ -0,0 +1,122 @@
+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/
+// TIMESTAMP class, so this file never reaches for a `boolean` scalar). The function-return
+// registry (R5) is worked through the core/aggregate/date/math references — lang_corefunc.html,
+// lang_aggfunc.html, lang_datefunc.html, lang_mathfunc.html — and stays deliberately incomplete:
+// SQLite's dynamic/flexible typing (lang_expr.html, datatype3.html) makes several documented
+// "returns a number" functions genuinely value- or modifier-dependent (SUM/AVG/MAX/MIN's
+// argument-shaped results, unixepoch()'s subsec-modifier int/float switch, every lang_mathfunc.html
+// entry's undocumented storage class for its "representable integer" wording) — those stay
+// unregistered by design, not by oversight. SQLITE_ALIASES stays empty: a CREATE TABLE column's
+// declared type name is matched by SUBSTRING against a small pattern set to pick one of five
+// *type affinities* (datatype3.html §3.1 "Determination Of Column Affinity"), not looked up in a
+// fixed alias table the way other dialects' declared types are — that affinity algorithm is a
+// distinct, not-yet-built feature, not a registration gap. Contract holds throughout: an absent
+// rule yields `unknown`, never a guess.
+// ---------------------------------------------------------------------------
+export const SQLITE_ALIASES = {};
+export function sqliteParseType(text) {
+    return parseType(text, SQLITE_ALIASES, fold);
+}
+const S = scalar("string");
+const I = scalar("int");
+const BIG = scalar("bigint");
+const D = scalar("double");
+const BIN = scalar("binary");
+const fixed = (t) => () => t;
+/** "returns argument X unchanged" (likelihood/likely/unlikely) / plain numeric passthrough (abs). */
+const firstArg = (args) => args[0] ?? UNKNOWN;
+/** coalesce/ifnull: "returns a copy of its first non-NULL argument" — the common type of the args
+ *  (falls back to unknown, never a guess, when they don't agree). */
+const common = (args) => commonType(args);
+function group(rule, names) {
+    return Object.fromEntries(names.map((n) => [n, rule]));
+}
+/** SQLite literal forms, by storage class (sqlite.org/datatype3.html has exactly five: NULL,
+ *  INTEGER, REAL, TEXT, BLOB — there is no native BOOLEAN or DATE/TIME/TIMESTAMP class).
+ *  TRUE/FALSE are literal aliases for the integers 1/0, not a boolean type
+ *  (sqlite.org/lang_expr.html#literal_values_constants_). CURRENT_TIME/CURRENT_DATE/
+ *  CURRENT_TIMESTAMP expand to a formatted TEXT value (sqlite.org/lang_createtable.html
+ *  §"The DEFAULT clause"), not a date/time type. */
+export function sqliteLiteral(text) {
+    const t = text.trim();
+    if (/^'/.test(t))
+        return S; // STRING_LITERAL
+    if (/^x'/i.test(t))
+        return BIN; // BLOB_LITERAL — X'...'
+    if (/^null$/i.test(t))
+        return UNKNOWN;
+    if (/^(true|false)$/i.test(t))
+        return I; // integer aliases, not a boolean type
+    if (/^current_(time|date|timestamp)$/i.test(t))
+        return S;
+    if (/^[+-]?0x[0-9a-f](_?[0-9a-f])*$/i.test(t))
+        return I; // hex integer literal
+    if (/^[+-]?\d(_?\d)*$/.test(t))
+        return I; // plain integer, no '.' or exponent
+    if (/^[+-]?(\d(_?\d)*)?\.(\d(_?\d)*)?([eE][+-]?\d+)?$/.test(t) && /\d/.test(t))
+        return D; // has a '.'
+    if (/^[+-]?\d(_?\d)*[eE][+-]?\d+$/.test(t))
+        return D; // exponent form, no '.'
+    return UNKNOWN;
+}
+export const SQLITE_FUNCTION_RETURNS = {
+    // --- string — lang_corefunc.html: each of these is documented as unconditionally returning a
+    // string, independent of the argument's own storage class ------------------------------------
+    ...group(fixed(S), [
+        "upper", // "returns a copy of input string X in which all lower-case ASCII characters are converted to their upper-case equivalent"
+        "lower", // "returns a copy of string X with all ASCII characters converted to lower case"
+        "typeof", // "returns a string that indicates the datatype of the expression X: null, integer, real, text, or blob"
+        "hex", // "returns a string which is the upper-case hexadecimal rendering of the content of that blob"
+        "quote", // "returns the text of an SQL literal which is the value of its argument suitable for inclusion into an SQL statement"
+        "ltrim", // "returns a string formed by removing any and all characters that appear in Y from the left side"
+        "rtrim", // "returns a string formed by removing any and all characters that appear in Y from the right side"
+        "trim", // "returns a string formed by removing any and all characters that appear in Y from both ends of X"
+        "replace", // "returns a string formed by substituting string Z for every occurrence of string Y in string X"
+        "soundex", // "returns a string that is the soundex encoding of the string X"
+    ]),
+    // --- date/time — lang_datefunc.html: date/time/datetime/strftime/timediff all format to TEXT.
+    // unixepoch() is the one date function left OUT — its optional subsec modifier switches the
+    // return between integer and floating-point, a call-shape (not argument-type) dependency this
+    // registry has no precedent for modelling -----------------------------------------------------
+    ...group(fixed(S), ["date", "time", "datetime", "strftime", "timediff"]),
+    // --- aggregate text — lang_aggfunc.html ---------------------------------------------------------
+    ...group(fixed(S), ["group_concat", "string_agg"]), // "returns a string which is the concatenation of all non-NULL values of X"
+    // --- integer — lang_corefunc.html ---------------------------------------------------------------
+    ...group(fixed(I), [
+        "length", // text: "number of Unicode code points"; blob: "number of bytes" — an integer either way
+        "octet_length", // "returns the number of bytes in the encoding of text string X"
+        "unicode", // "returns the numeric unicode code point corresponding to the first character of the string X"
+        "instr", // "returns the number of prior characters plus 1, or 0 if Y is nowhere found within X"
+        "sign", // "returns -1, 0, or +1" — always one of those three integers, regardless of whether X is REAL or INTEGER
+    ]),
+    // --- bigint — values documented across the full 64-bit signed range --------------------------
+    count: fixed(BIG), // lang_aggfunc.html: "returns a count of the number of times that X is not NULL in a group"
+    random: fixed(BIG), // lang_corefunc.html: "returns a pseudo-random integer between -9223372036854775807 and +9223372036854775807"
+    // --- real/double ---------------------------------------------------------------------------------
+    round: fixed(D), // lang_corefunc.html: "returns a floating-point value X rounded to Y digits" — always real, even round(X) with no Y
+    total: fixed(D), // lang_aggfunc.html: "result of total() is always a floating point value" (documented always-float, unlike sum())
+    avg: fixed(D), // lang_aggfunc.html: "is always a floating point value whenever there is at least one non-NULL input" — unlike other dialects' input-typed AVG
+    julianday: fixed(D), // lang_datefunc.html: "the Julian day - the fractional number of days since noon in Greenwich..."
+    // --- blob ------------------------------------------------------------------------------------------
+    ...group(fixed(BIN), [
+        "unhex", // "returns a BLOB value which is the decoding of the hexadecimal string X"
+        "zeroblob", // "returns a BLOB consisting of N bytes of 0x00"
+        "randomblob", // "return an N-byte blob containing pseudo-random bytes"
+    ]),
+    // --- passthrough — lang_corefunc.html -----------------------------------------------------------
+    abs: firstArg, // "returns the absolute value of the numeric argument X" — same numeric family as its input (firstArg is the universal cross-dialect precedent for abs)
+    ...group(firstArg, ["likelihood", "likely", "unlikely"]), // each: "returns argument X unchanged"
+    // --- aggregate widening ------------------------------------------------------------------------
+    // lang_aggfunc.html: "sum(X) ... Returns an integer if all inputs are integers; otherwise
+    // returns floating-point" — exactly the int-family→bigint / float→double / decimal→decimal
+    // shape widenSum already encodes (the same rule databricks/snowflake/redshift use verbatim).
+    sum: (args) => widenSum(args[0] ?? UNKNOWN),
+    // --- common-type — lang_corefunc.html: "returns a copy of its first non-NULL argument" -----------
+    coalesce: common,
+    ifnull: common,
+};

package/dist/sqlite/lower.d.ts

@@ -0,0 +1,11 @@
+import { ParserRuleContext } from "antlr4ng";
+import type { QueryExpr } from "../ir/ir.js";
+import { type StatementCategory } from "../ir/statement.js";
+/** Lower a parsed SQLite file (`parse`: a `;`-separated sql_stmt_list) into the IR. A single
+ *  SELECT/VALUES statement lowers fully; anything else (DDL/DML/pragma/utility, multi-statement
+ *  batches, EXPLAIN) becomes a flagged non-query body — a valid parse never throws. */
+export declare function lower(tree: ParserRuleContext): QueryExpr;
+/** Per-statement categories for every `sql_stmt` in a parsed `parse`, in source order — the
+ *  file-level view behind statementCategory (which folds >1 into "compound"). Parity with the
+ *  other dialects; feeds the corpus reclassifier. */
+export declare function statementCategories(tree: ParserRuleContext): StatementCategory[];