sqllens 1.0.0 → 1.2.0

package/dist/completion/parser-factory.js

@@ -15,6 +15,10 @@ import { DuckdbLexer } from "../generated/duckdb/DuckdbLexer.js";
 import { DuckdbParser } from "../generated/duckdb/DuckdbParser.js";
 import { TrinoLexer } from "../generated/trino/TrinoLexer.js";
 import { TrinoParser } from "../generated/trino/TrinoParser.js";
+import { SqliteLexer } from "../generated/sqlite/SqliteLexer.js";
+import { SqliteParser } from "../generated/sqlite/SqliteParser.js";
+import { MysqlLexer } from "../generated/mysql/MysqlLexer.js";
+import { MysqlParser } from "../generated/mysql/MysqlParser.js";
 function databricksFactory(sql) {
     const lexer = new DatabricksLexer(CharStream.fromString(sql));
     const tokenStream = new CommonTokenStream(lexer);
@@ -141,6 +145,36 @@ function trinoFactory(sql) {
         runEntry: () => parser.root(),
     };
 }
+function sqliteFactory(sql) {
+    const lexer = new SqliteLexer(CharStream.fromString(sql));
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new SqliteParser(tokenStream);
+    parser.errorHandler = new DefaultErrorStrategy();
+    lexer.removeErrorListeners();
+    parser.removeErrorListeners();
+    return {
+        parser,
+        lexer,
+        tokenStream,
+        entryRuleIndex: SqliteParser.RULE_parse,
+        runEntry: () => parser.parse(),
+    };
+}
+function mysqlFactory(sql) {
+    const lexer = new MysqlLexer(CharStream.fromString(sql));
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new MysqlParser(tokenStream);
+    parser.errorHandler = new DefaultErrorStrategy();
+    lexer.removeErrorListeners();
+    parser.removeErrorListeners();
+    return {
+        parser,
+        lexer,
+        tokenStream,
+        entryRuleIndex: MysqlParser.RULE_root,
+        runEntry: () => parser.root(),
+    };
+}
 const FACTORIES = {
     databricks: databricksFactory,
     tsql: tsqlFactory,
@@ -150,8 +184,22 @@ const FACTORIES = {
     postgres: postgresFactory,
     duckdb: duckdbFactory,
     trino: trinoFactory,
+    sqlite: sqliteFactory,
+    mysql: mysqlFactory,
 };
 /** Build a fresh error-tolerant parser for `dialect`, lexing `sql`. */
 export function makeParser(sql, dialect) {
     return FACTORIES[dialect](sql);
 }
+const META_CACHE = new Map();
+/** The cached {@link CompletionMeta} for `dialect`, built once. Completion drives the walk over the
+ *  document's own token stream plus this meta, instead of re-parsing the source text. */
+export function completionMeta(dialect) {
+    let meta = META_CACHE.get(dialect);
+    if (!meta) {
+        const m = makeParser("", dialect);
+        meta = { atn: m.parser.atn, vocabulary: m.lexer.vocabulary, entryRuleIndex: m.entryRuleIndex };
+        META_CACHE.set(dialect, meta);
+    }
+    return meta;
+}

package/dist/databricks/behavior.d.ts

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

package/dist/databricks/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 { databricksLiteral, databricksParseType, DATABRICKS_FUNCTION_RETURNS } from "./infer.js";
+export const databricksBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: databricksLiteral,
+    parseType: databricksParseType,
+    functions: DATABRICKS_FUNCTION_RETURNS,
+    division: "float",
+    signatures: SIGNATURES.databricks,
+    // Databricks implicit coercion: STRING containing a number coerces to numeric (STR_TO_NUM=true), no bool<->num (BOOL_NUM=false).
+    accepts: (argType, paramText) => acceptsFor(databricksParseType, true, false, argType, paramText),
+};

package/dist/databricks/fold.d.ts

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

@@ -0,0 +1,27 @@
+// Databricks 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).
+// docs.databricks.com/en/sql/language-manual/sql-ref-identifiers.html — verified live:
+// "Identifiers are case-insensitive when referenced." Backtick escaping is doubling, not
+// case-quoting: "Use ` to escape ` itself" (example: `` `a``b` `` → `` a`b ``).
+import { displayWith, foldWith } from "../ident/fold.js";
+const BACKTICK = ["`", "`"];
+export const DATABRICKS_FOLD_RULE = {
+    delimiters: [BACKTICK],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its Databricks identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(DATABRICKS_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(DATABRICKS_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/databricks/index.d.ts

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

package/dist/databricks/index.js

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

package/dist/databricks/infer.d.ts

@@ -0,0 +1,6 @@
+import { type FnRule } from "../infer/functions.js";
+import { type Type } from "../infer/types.js";
+export declare const DATABRICKS_FUNCTION_RETURNS: Record<string, FnRule>;
+/** Databricks/Spark literal forms. */
+export declare function databricksLiteral(text: string): Type;
+export declare function databricksParseType(text: string): Type;