sqllens 1.0.0 → 1.1.0

package/LICENSE

@@ -19,13 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
----
-
-This MIT license covers the original sqllens source: everything under src/
-(excluding generated output), tools/, tests/, and the project documentation.
-
-The hand-maintained ANTLR grammars under grammars/ are forks of third-party
-grammars and remain under their upstream licenses (Apache-2.0, BSD-3-Clause, and
-MIT, depending on the grammar). Each grammar file retains its original license
-header, and the full per-grammar attributions are in THIRD-PARTY-NOTICES.md.

package/README.md

@@ -2,13 +2,16 @@
 
 [![npm version](https://img.shields.io/npm/v/sqllens)](https://www.npmjs.com/package/sqllens) [![license](https://img.shields.io/npm/l/sqllens)](LICENSE)
 
-A TypeScript SQL parser and static analyzer. It parses SQL into a tree, lowers it
-to a dialect-neutral intermediate representation (IR), and runs a semantic layer
-over that IR: name resolution (scope), schema-fed qualification, type inference,
-and column lineage. Give it a
+A TypeScript SQL parser and static analyzer. It parses SQL into a syntax tree
+(AST), lowers it to a dialect-neutral intermediate representation (IR), and runs
+a semantic layer over that IR: name resolution (scope), schema-fed qualification,
+type inference, and column lineage. Give it a
 query and it tells you the query's sources, its output columns, their types, and
 where each column comes from. The parsers are generated TypeScript on the
-[antlr4ng](https://github.com/mike-lischke/antlr4ng) runtime.
+[antlr4ng](https://github.com/mike-lischke/antlr4ng) runtime. Dialects covered:
+Databricks (Spark SQL), T-SQL, Snowflake, BigQuery (GoogleSQL), Redshift,
+PostgreSQL, DuckDB, Trino, SQLite, and MySQL, plus derived engines such as
+Athena, Fabric, and MariaDB (see [Dialects](#dialects)).
 
 The front end is error-tolerant and token-first, so the library drives editor
 features (completion, hover, diagnostics, go-to-definition) over incomplete,
@@ -32,9 +35,9 @@ q.lineage.originsOf("total");  // → orders.total
 
 ## Dialects
 
-sqllens implements eight SQL dialects directly, each with its own grammar. Seven
-more engines are covered as *derived dialects*: their SQL is already parsed by one
-of those eight grammars, for 15 engines in total.
+sqllens implements the major SQL dialects directly, each with its own grammar.
+More engines are covered as *derived dialects*: their SQL is already parsed by
+one of the primary grammars.
 
 | Dialect | Derived dialects | Parse + lower | Semantic layer | Notes |
 |---|---|---|---|---|
@@ -46,6 +49,8 @@ of those eight grammars, for 15 engines in total.
 | PostgreSQL | — | yes | yes | grammar forked from `bytebase/parser` `postgresql/` (BSD-3, PG18 keywords) |
 | DuckDB | — | yes | yes | grammar forked from this repo's own postgres pair (no open ANTLR grammar exists) |
 | Trino | Presto, Amazon Athena | yes | yes | grammar is the first-party trinodb `SqlBase.g4` (release 482), mechanically split |
+| SQLite | — | yes | yes | grammar forked from grammars-v4 `sql/sqlite` (MIT); entry rule `parse` |
+| MySQL | MariaDB (partial — ordinary DQL/DML only, MariaDB-only extensions unmodeled) | yes | yes | grammar forked from grammars-v4 `sql/mysql/Positive-Technologies` (MIT); entry rule `root` |
 
 Each grammar began as a fork of the upstream noted above, but most are now far from
 verbatim copies. They've had substantial extension and correction, driven by a full
@@ -58,9 +63,21 @@ the primary dialect's. Microsoft Fabric runs a restricted subset of T-SQL, Amazo
 Athena's engine is Trino, and AWS Glue runs Spark. Each one is checked against real
 SQL from that engine before it goes on the list.
 
-In code, the `dialect` argument is one of `"databricks" | "tsql" | "snowflake" | "bigquery" | "redshift" | "postgres" | "duckdb" | "trino"`. `resolveDialect` turns an
-engine name (or a dialect name) into the one that parses it: `resolveDialect("athena")`
-returns `"trino"`.
+In code, the `dialect` argument is a plain string, and `resolveDialect` turns an
+engine name (or a dialect name) into the dialect that parses its SQL:
+
+```ts
+import { parse, resolveDialect } from "sqllens";
+
+// dialect strings: "databricks" | "tsql" | "snowflake" | "bigquery" |
+// "redshift" | "postgres" | "duckdb" | "trino" | "sqlite" | "mysql"
+parse("SELECT 1", "snowflake");
+
+// engine name → the dialect that parses it
+resolveDialect("athena"); // "trino"
+resolveDialect("fabric"); // "tsql"
+resolveDialect("mariadb"); // "mysql"
+```
 
 The semantic layer is dialect-agnostic: it operates on the shared IR and runs
 unchanged on every dialect. Only the parse and lower stages are dialect-specific.
@@ -73,7 +90,7 @@ parse → lower → resolveScopes → qualify → infer / lineage / symbols
 
 Each stage produces one value, and that value is what a specific editor feature
 reads from. Only the first two stages, parse and lower, are dialect-specific;
-everything after them is shared and runs unchanged across all eight dialects.
+everything after them is shared and runs unchanged across every dialect.
 
 **parse** turns SQL text into a *concrete syntax tree* (CST): the full parse tree,
 every token and grammar node exactly as written, nothing dropped or simplified. It
@@ -285,6 +302,41 @@ invariants the conformance gates check. Tokens tile the source byte-for-byte, ev
 span is in original document coordinates, broken input never throws, and tag-free
 text is identical to a plain parse.
 
+## Broken and incomplete SQL
+
+sqllens is error-tolerant by construction, because its first consumer is an
+editor and editor input is mid-keystroke most of the time. Parsing broken,
+partial, or invalid SQL never throws: syntax errors come back as positioned
+diagnostics (line, column, offset, length), ready for editor squiggles, and
+the rest of the result stays usable.
+
+```ts
+import { parse } from "sqllens";
+
+// mid-edit input: a dangling comma and an unfinished WHERE
+const r = parse("SELECT total, FROM orders WHERE", "postgres");
+
+r.errors; // 1 — counted, not thrown
+r.diagnostics[0]; // { message: "mismatched input ','…", line: 1, column: 12, offset: 12, length: 1 }
+r.ast; // still a usable IR — lower() is total on broken input
+r.tokens.length; // 10 — the full token stream, exact spans intact
+```
+
+Every downstream pass keeps the same contract: `lower()` yields a flagged IR
+instead of throwing, statement-level containment keeps one broken statement
+from taking down its neighbors, and the interactive features run on the
+broken text directly:
+
+```ts
+import { SqlSession, Schema } from "sqllens";
+
+const schema = new Schema({ orders: { id: "int", total: "decimal" } });
+
+// the projection slot is empty — the user just hasn't typed it yet
+const s = SqlSession.create("SELECT  FROM orders", "postgres", { schema });
+s.completeAt(7); // candidates for the empty slot: total, id, keywords, functions
+```
+
 ## Editor / language tooling
 
 The front end is error-tolerant and token-first, so it serves editor features
@@ -309,6 +361,17 @@ that run on incomplete, mid-edit text. They never need a clean parse:
   of the symbol under the cursor; backs find-references, document highlight, and
   code-lens reference counts.
 
+To tokenize SQL without parsing at all, `tokenize` is lexer-only and works on
+any text, including text no parser would accept:
+
+```ts
+import { tokenize } from "sqllens";
+
+const tokens = tokenize("SELECT amount FROM sales", "snowflake");
+tokens[0]; // { text: "SELECT", start: 0, stop: 5, line: 1, column: 0, role: "keyword", channel: 0, … }
+tokens[1]; // whitespace rides the hidden channel: { text: " ", channel: 1, role: "whitespace", … }
+```
+
 ```ts
 import { SqlDocument, Schema } from "sqllens";
 
@@ -388,6 +451,25 @@ deferred items are tracked work: rename and
 code actions are the next LSP phase, workspace symbols need the project model,
 and formatting is expected to wrap an existing external formatter.
 
+## How sqllens compares
+
+The SQL-parser field splits into parse-only libraries and semantic tools bound
+to a single borrowed parser. The full survey, with the whole field catalogued,
+is in [docs/sql-parser-landscape.md](docs/sql-parser-landscape.md); the short
+version against the libraries people usually reach for:
+
+| | Language | Dialect breadth | Semantic analysis | Error-tolerant, editor-grade |
+|---|---|---|---|---|
+| **sqllens** | TypeScript | Databricks, T-SQL, Snowflake, BigQuery, Redshift, PostgreSQL, DuckDB, Trino, SQLite, MySQL | scope, schema qualification, type inference, column lineage, symbols | yes: parses mid-keystroke input, positioned diagnostics, total pipeline |
+| [sqlglot](https://github.com/tobymao/sqlglot) | Python | 31 dialects | transpile, optimize, qualify, lineage | no: a batch library, not built for per-keystroke reparse |
+| [node-sql-parser](https://github.com/taozhi8833998/node-sql-parser) | JS/TS | MySQL, PostgreSQL, and more | table/column lists only; no lineage, no types | no |
+| [sqllineage](https://github.com/reata/sqllineage) | Python | via sqlfluff's parser | column lineage only | no |
+| [libpg_query](https://github.com/pganalyze/libpg_query) | C (bindings) | PostgreSQL, exact | parse only | no: one syntax error fails the whole buffer |
+
+The corner sqllens occupies: multi-dialect breadth, schema-fed semantics, and
+editor-grade error tolerance in one TypeScript library. Each piece exists
+elsewhere; the combination did not.
+
 ## Architecture
 
 One folder per dialect; no shared "core" grammar and no grammar inheritance. Each

package/THIRD-PARTY-NOTICES.md

@@ -100,6 +100,26 @@ Forked from [antlr/grammars-v4](https://github.com/antlr/grammars-v4)
 `sql/snowflake`. Copyright (c) 2022 Michał Lorek. Licensed under the MIT License
 (full text retained in the file header).
 
+### SQLite grammar — MIT
+
+`grammars/sqlite/SqliteLexer.g4`, `grammars/sqlite/SqliteParser.g4`
+
+Forked from [antlr/grammars-v4](https://github.com/antlr/grammars-v4) `sql/sqlite`
+(upstream commit `8af0d4c26c796ea27c15c3d85418f2d0f77c3adb`, retrieved 2026-07-10).
+Copyright (c) 2020 Martin Mirchev; (c) 2014 Bart Kiers. Licensed under the MIT
+License (full text retained in the file headers).
+
+### MySQL grammar — MIT
+
+`grammars/mysql/MysqlLexer.g4`, `grammars/mysql/MysqlParser.g4`
+
+Forked from [antlr/grammars-v4](https://github.com/antlr/grammars-v4)
+`sql/mysql/Positive-Technologies` (upstream commit
+`bf61744020dc46f2d7b8761e35b0c0cb39b3f31a`, retrieved 2026-07-10) — not the
+`sql/mysql/Oracle` sibling variant. Copyright (c) 2015-2017 Ivan Kochurkin,
+Positive Technologies; (c) 2017 Ivan Khudyashev. Licensed under the MIT License
+(full text retained in the file headers).
+
 ## Runtime and build dependencies (not redistributed in source)
 
 - **antlr4ng** — the TypeScript ANTLR runtime (BSD-3-Clause). Runtime dependency.

package/dist/api.js

@@ -27,6 +27,10 @@ import { parseDuckdb } from "./duckdb/parse.js";
 import { lower as lowerDuckdb } from "./duckdb/lower.js";
 import { parseTrino } from "./trino/parse.js";
 import { lower as lowerTrino } from "./trino/lower.js";
+import { parseSqlite } from "./sqlite/parse.js";
+import { lower as lowerSqlite } from "./sqlite/lower.js";
+import { parseMysql } from "./mysql/parse.js";
+import { lower as lowerMysql } from "./mysql/lower.js";
 import { resolveScopes } from "./scope/scope.js";
 import { qualify as qualifyScopes } from "./qualify/qualify.js";
 import { OPEN_PROVIDER } from "./qualify/template-provider.js";
@@ -43,6 +47,8 @@ const DIALECTS = {
     postgres: { parse: parsePostgres, lower: lowerPostgres },
     duckdb: { parse: parseDuckdb, lower: lowerDuckdb },
     trino: { parse: parseTrino, lower: lowerTrino },
+    sqlite: { parse: parseSqlite, lower: lowerSqlite },
+    mysql: { parse: parseMysql, lower: lowerMysql },
 };
 /**
  * Parse one statement (or a dialect's statement batch) and lower it to the IR. Dispatches on

package/dist/completion/config.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";
 // Databricks (Spark grammar) name-reference rules — each cited by its grammar rule:
 //   identifierReference  → the table/view/name reference used in `relationPrimary` (post-FROM),
 //                          `DatabricksParser.g4:755` (`IDENTIFIER(expr)` | multipartIdentifier).
@@ -116,6 +120,52 @@ const TRINO_NAME_TOKENS = new Set([
     TrinoLexer.BACKQUOTED_IDENTIFIER,
     TrinoLexer.DIGIT_IDENTIFIER,
 ]);
+// ── SQLite (grammars-v4 fork) ───────────────────────────────────────────────
+//   post-FROM   → table_name (the relation-name leaf; the enclosing `table_or_subquery` is a
+//                 wider alternation that also recurses into `select_stmt` for a parenthesized
+//                 subquery/join, so marking IT preferred would swallow completion inside a nested
+//                 FROM (SELECT …) — table_name alone still fires at "FROM ‹›" with nothing typed,
+//                 since the ATN walk explores entering it before any token is consumed. table_name
+//                 is also the slot reused by INSERT INTO/UPDATE/ALTER/DROP/CREATE TABLE's table-name
+//                 position, which is a bonus, not a target).
+//   SELECT/WHERE → expr (the value/column slot; expr_base's `column_name_excluding_string` and the
+//                 qualified `table_name DOT column_name` form both nest under it, matching the
+//                 Snowflake `expr` precedent — a single outer entry rule for the whole
+//                 precedence-chain expression grammar).
+// table_name ALSO appears inside expr_base's qualified-column-ref and `x IN table_name` forms; since
+// expr is the outer frame there, those inner positions report columnRules only, not tableRules — a
+// known, accepted imprecision (same shape as the other dialects' rule choices here).
+const SQLITE_TABLE_RULES = new Set([SqliteParser.RULE_table_name]);
+const SQLITE_COLUMN_RULES = new Set([SqliteParser.RULE_expr]);
+const SQLITE_PREFERRED = new Set([...SQLITE_TABLE_RULES, ...SQLITE_COLUMN_RULES]);
+const SQLITE_RELATION_KEYWORDS = new Set([SqliteLexer.FROM_, SqliteLexer.JOIN_]);
+// SQLite's lexer folds plain/"double"/`backtick`/[bracket]-quoted names into ONE IDENTIFIER token
+// (SqliteLexer.g4's IDENTIFIER rule matches all four forms), so there is no separate quoted-ident
+// token type to add, unlike T-SQL/Trino/Postgres.
+const SQLITE_NAME_TOKENS = new Set([SqliteLexer.IDENTIFIER]);
+// ── MySQL (grammars-v4 mysql/Positive-Technologies fork) ───────────────────
+//   post-FROM   → tableName (the relation-name leaf; the enclosing `tableSourceItem` is a wider
+//                 4-way alternation whose `subqueryTableItem` arm recurses into `selectStatement`
+//                 for a parenthesized subquery, so marking IT preferred would swallow completion
+//                 inside a nested "FROM (SELECT ... FROM ‹›)" — same table_or_subquery-vs-table_name
+//                 trap as the SQLite entry above. tableName wraps fullId -> uid, so it still fires at
+//                 "FROM ‹›" with nothing typed. tableName is also reused by INSERT INTO/UPDATE/DELETE/
+//                 DDL's table-name slot, a bonus, not a target).
+//   SELECT/WHERE → expression (the outer frame of the expression -> predicate -> expressionAtom
+//                 precedence chain; fullColumnName nests under it, matching the Snowflake/SQLite
+//                 `expr`-as-single-outer-rule precedent).
+// tableName ALSO appears inside fullColumnName-adjacent and IN-list positions reached from inside
+// `expression`; since expression is the outer frame there, those inner positions report columnRules
+// only, not tableRules — the same accepted imprecision as the other dialects' choices here.
+const MYSQL_TABLE_RULES = new Set([MysqlParser.RULE_tableName]);
+const MYSQL_COLUMN_RULES = new Set([MysqlParser.RULE_expression]);
+const MYSQL_PREFERRED = new Set([...MYSQL_TABLE_RULES, ...MYSQL_COLUMN_RULES]);
+const MYSQL_RELATION_KEYWORDS = new Set([MysqlLexer.FROM, MysqlLexer.JOIN]);
+// MySQL's `uid` rule (the identifier slot fullId/tableName bottom out on) accepts simpleId (built on
+// the plain ID token) or STRING_LITERAL — this fork's DOUBLE_QUOTE_ID/REVERSE_QUOTE_ID alternatives
+// are commented out of `uid`, so backtick/double-quoted names lex to, and reach `uid` through,
+// STRING_LITERAL (docs/identifier-delimiter-contract.md's MySQL note says the same).
+const MYSQL_NAME_TOKENS = new Set([MysqlLexer.ID, MysqlLexer.STRING_LITERAL]);
 export const COMPLETION_CONFIG = {
     databricks: {
         preferredRules: DATABRICKS_PREFERRED,
@@ -181,4 +231,20 @@ export const COMPLETION_CONFIG = {
         relationKeywordTokens: TRINO_RELATION_KEYWORDS,
         nameTokens: TRINO_NAME_TOKENS,
     },
+    sqlite: {
+        preferredRules: SQLITE_PREFERRED,
+        ignoredTokens: new Set([Token.EOF]),
+        tableRules: SQLITE_TABLE_RULES,
+        columnRules: SQLITE_COLUMN_RULES,
+        relationKeywordTokens: SQLITE_RELATION_KEYWORDS,
+        nameTokens: SQLITE_NAME_TOKENS,
+    },
+    mysql: {
+        preferredRules: MYSQL_PREFERRED,
+        ignoredTokens: new Set([Token.EOF]),
+        tableRules: MYSQL_TABLE_RULES,
+        columnRules: MYSQL_COLUMN_RULES,
+        relationKeywordTokens: MYSQL_RELATION_KEYWORDS,
+        nameTokens: MYSQL_NAME_TOKENS,
+    },
 };

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,6 +184,8 @@ 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) {

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-symbols.js

@@ -75,6 +75,8 @@ 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 { SqliteLexer } from "./generated/sqlite/SqliteLexer.js";
+import { MysqlLexer } from "./generated/mysql/MysqlLexer.js";
 import { inferDialect } from "./infer/dialect.js";
 import { HOF_LAMBDA_ARG } from "./infer/infer.js";
 import { SCALAR_ALIASES, TSQL_ALIASES } from "./infer/types.js";
@@ -84,6 +86,8 @@ 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 { SQLITE_ALIASES } from "./infer/sqlite.js";
+import { MYSQL_ALIASES } from "./infer/mysql.js";
 import { FUNCTION_SIGNATURES, HARVESTED_SIGNATURES } from "./signature/signatures.js";
 // bigquery's generated lexer class is GoogleSQLLexer (the fork is Bytebase's GoogleSQL grammar).
 const LEXERS = {
@@ -95,6 +99,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 +113,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 (`'<>'`, `'::'`)

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";