pubspec.yaml 644 0 0 1175 14722143005 11211 0ustar0 pubpubname: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.40.0 homepage: https://github.com/simolus3/drift/tree/develop/sqlparser repository: https://github.com/simolus3/drift #homepage: https://drift.simonbinder.eu/ issue_tracker: https://github.com/simolus3/drift/issues topics: - drift - database - sql funding: - https://github.com/sponsors/simolus3 environment: sdk: '>=3.0.0 <4.0.0' dependencies: meta: ^1.3.0 collection: ^1.15.0 source_span: ^1.8.0 charcode: ^1.2.0 dev_dependencies: lints: ^4.0.0 test: ^1.17.4 path: ^1.8.0 ffi: ^2.0.0 sqlite3: ^2.0.0 example 755 0 0 0 0 7657 5ustar0 pubpubexample/sqlparser_example.dart 644 0 0 3620 14714753444 14736 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; // Example that parses a select statement on some tables defined below and // prints what columns would be returned by that statement. void main() { final engine = SqlEngine() ..registerTableFromSql( ''' CREATE TABLE frameworks ( id INTEGER NOT NULL PRIMARY KEY, name TEXT NOT NULL, popularity REAL NOT NULL ); ''', ) ..registerTableFromSql( ''' CREATE TABLE languages ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL ); ''', ) ..registerTableFromSql( ''' CREATE TABLE uses_language ( framework INTEGER NOT NULL REFERENCES frameworks (id), language INTEGER NOT NULL REFERENCES languages (id), PRIMARY KEY (framework, language) ); ''', ); // Use SqlEngine.analyze to parse a single sql statement and analyze it. // Analysis can be used to find semantic errors, lints and inferred types of // expressions or result columns. final result = engine.analyze(''' SELECT f.* FROM frameworks f INNER JOIN uses_language ul ON ul.framework = f.id INNER JOIN languages l ON l.id = ul.language WHERE l.name = 'Dart' ORDER BY f.name ASC, f.popularity DESC LIMIT 5 OFFSET 5 * 3 '''); result.errors.forEach(print); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; print('the query returns ${columns.length} columns'); for (final column in columns) { final type = result.typeOf(column); print('${column.name}, which will be a $type'); } } extension on SqlEngine { /// Utility function that parses a `CREATE TABLE` statement and registers the /// created table to the engine. void registerTableFromSql(String createTable) { final stmt = parse(createTable).rootNode as CreateTableStatement; registerTable(schemaReader.read(stmt)); } } README.md 644 0 0 6100 14612235271 10141 0ustar0 pubpub# sqlparser SQL parser and static analyzer written in Dart. At the moment, this library targets the SQLite dialect only. ## Features This library aims to support every SQLite feature, which includes parsing and detailed static analysis. We can resolve what type a column in a `SELECT` statement has, infer types for variables, find semantic errors and more. This library supports most SQLite features: - DQL: Full support, including joins, `group by`, nested and compound selects, `WITH` clauses and window functions - DDL: Supports `CREATE TABLE` statements, including advanced features like foreign keys or virtual tables (when a matching module like `fts5` is enabled). This library also supports `CREATE TRIGGER` and `CREATE INDEX` statements. ### Using the parser To obtain an abstract syntax tree from an SQL statement, use `SqlEngine.parse`. ```dart import 'package:sqlparser/sqlparser.dart'; final engine = SqlEngine(); final result = engine.parse(''' SELECT f.* FROM frameworks f INNER JOIN uses_language ul ON ul.framework = f.id INNER JOIN languages l ON l.id = ul.language WHERE l.name = 'Dart' ORDER BY f.name ASC, f.popularity DESC LIMIT 5 OFFSET 5 * 3 '''); // result.rootNode contains the select statement in tree form ``` ### Analysis Given information about all tables and an SQL statement, this library can: 1. Determine which result columns a query is going to have, including types and nullability 2. Make an educated guess about what type the variables in the query should have (it's not really possible to be 100% accurate about this because SQLite is very flexible at types, but this library gets it mostly right) 3. Issue basic warnings about queries that are syntactically valid but won't run (references unknown tables / columns, uses undefined functions, etc.) To use the analyzer, first register all known tables via `SqlEngine.registerTable`. Then, `SqlEngine.analyze(sql)` gives you an `AnalysisContext` which contains an annotated AST and information about errors. The type of result columns and expressions can be inferred by using `AnalysisContext.typeOf()`. Here's an example: ```dart final id = TableColumn('id', const ResolvedType(type: BasicType.int)); final content = TableColumn('content', const ResolvedType(type: BasicType.text)); final demoTable = Table( name: 'demo', resolvedColumns: [id, content], ); final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT id, d.content, *, 3 + 4 FROM demo AS d'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns; resolvedColumns.map((c) => c.name); // id, content, id, content, 3 + 4 resolvedColumns.map((c) => context.typeOf(c).type.type); // int, text, int, text, int, int ``` ## But why? [Drift](https://pub.dev/packages/drift), a persistence library for Dart apps, uses this package to generate type-safe methods from SQL. ## Thanks - To [Bob Nystrom](https://github.com/munificent) for his amazing ["Crafting Interpreters"](https://craftinginterpreters.com/) book, which was incredibly helpful when writing the parser. LICENSE 644 0 0 2055 14345646642 7707 0ustar0 pubpubMIT License Copyright (c) 2019 Simon Binder Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 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. CHANGELOG.md 644 0 0 27240 14722143005 10516 0ustar0 pubpub## 0.40.0 - Add support for the `dbstat` module. - Prioritize null propagation in type resolver, leading to more accurate analysis on which columns are nullable. ## 0.39.2 - Fix false-positive lint for a parameter count mismatch on `bm25()`. - Fix type interference around `fts5` function calls. ## 0.39.1 - Improve recovery in parser when encountering syntax errors. ## 0.39.0 - When using the `parse` methods on `SqlEngine`, tokenizer errors are now included in the result instead of throwing an exception. ## 0.38.1 - Fix upcoming `unreachable_switch_default` lint. ## 0.38.0 - Resolve `json_extract` return types from context if possible. - Warn when `INSTEAD OF` triggers are not used on views. - Represent writes to views in `TableWrite`. ## 0.37.1 - Refine nullability analysis for subquery expressions: Queries with aggregate invocations are no longer considered nullable (the aggregate invocation had to be a top-level expression before). ## 0.37.0 - Add support for sqlite 3.46.0. - Make columns coming from subquery expressions nullable. ## 0.36.0 - Add support for the geopoly module. ## 0.35.1 - Fix `IN` expressions accepting aliases, causing some queries to get parsed incorrectly. ## 0.35.0 - Fix parsing binary literals. - Expand support for `IN` expressions, they now support tuples on the left-hand side and the shorthand syntax for table references and table-valued functions. - Drift extensions: Allow custom class names for `CREATE VIEW` statements. - Drift extensions: Support the `INT64` hint for `CREATE TABLE` statements. ## 0.34.1 - Allow selecting from virtual tables using the table-valued function syntax. ## 0.34.0 - Fix explicit `NULL` column constraints being dropped when converting nodes to SQL. - Add analysis errors for illegal unqualified references to `old` and `new` in triggers. - Analysis support for sqlite 3.45 and jsonb functions. ## 0.33.0 - Support the [column-name-list](https://sqlite.org/syntax/column-name-list.html) syntax for updates, thanks to [@tibotix](https://github.com/tibotix). ## 0.32.1 - Treat the result of `sum()` as nullable when inferring types. - Support features added in sqlite 3.44: - `ORDER BY` clauses as part of aggregate functions. - Support `concat`, `concat_ws` and `string_agg`. ## 0.32.0 - Turn `ResolvedType.hints` into a list, supporting multiple type hints. ## 0.31.3 - Fix star columns expanding to more columns than they should. ## 0.31.2 - Add `CaseInsensitiveMap.of` to wrap existing maps. ## 0.31.1 - Add the `sqlite3_schema` table to the builtin tables supported by every `SqlEngine` instance. - Support the `timediff` and `octet_length` functions from sqlite 3.43.0. ## 0.31.0 - Add `SqlEngine.parseMultiple` to parse multiple statements into one AST. ## 0.30.3 - Fix `WITH` clauses not being resolved for compound select statements. ## 0.30.2 - Fix false-positive "unknown table" errors when the same table is used in a join with and then without an alias. ## 0.30.1 - Report syntax error for `WITH` clauses in triggers. ## 0.30.0 - Add `previous` and `next` fields for tokens ## 0.29.0 - Parser support for constructor names in `WITH` drift syntax. - Support resolving `IIF` functions. - Fix a crash when a CTE is used on an insert, update or delete statement. - Fix wrong column names being reported for references in subqueries and CTEs. ## 0.28.1 - Fix false-positive warnings about `AS` aliases in subqueries used in triggers. ## 0.28.0 - Support the `unhex` function added in sqlite 3.41.0 - Support custom keyword sets when formatting SQL. ## 0.27.0 - Add `mappedBy` to `ExpressionResultColumn` when parsing in drift mode. ## 0.26.1 - Fix missing space when formatting aggregate functions. ## 0.26.0 - Remove token parameter from constructor in `Literal` subclasses and `NumberedVariable`. ## 0.25.0 - Better analysis support for `ANY` columns in `STRICT` tables. - Assign resolved schema columns to synctactical `ResultColumn` in queries. ## 0.24.0 - Make `Fts5Table` constructor public. ## 0.23.3 - Analysis support for the spellfix extension. ## 0.23.2 - Support resolving the `fts5vocab` module when `fts5` is enabled - thanks to [@FaFre](https://github.com/FaFre). - Support the `rtree` extension - also thanks to [@FaFre](https://github.com/FaFre)! - Improve references resolving across subqueries. ## 0.23.1 - Gracefully handle tokenizer errors related to `@` or `$` variables. ## 0.23.0 - Apply type hints for date times on textual datetime functions as well. ## 0.22.0 - Refactor how tables and columns are resolved internally. - Lint for `DISTINCT` misuse in aggregate function calls. - Support the `RIGHT` and `FULL` join operators added in sqlite 3.39.0. - Support `IS DISTINCT FROM` and `IS NOT DISTINCT FROM` syntax added in sqlite 3.39.0. - Fix type inference for `SUM()` calls around int "subtypes" (like booleans). ## 0.21.0 - Analysis support for new features in sqlite version 3.38. - Replace internal `moor` references with `drift` references. ## 0.20.1 - Fix SQL generation for upsert statements with a conflict target. ## 0.20.0 - Support `LIST` columns for a drift-specific feature. ## 0.19.2 - Improve handling of drift-specific column types in `STRICT` tables. ## 0.19.1 - Make the result of `group_concat` nullable. ## 0.19.0 - Support generated columns. - Support features introduced in sqlite version 3.37, most notably `STRICT` tables. ## 0.18.1 - Fix the AST comparator missing errors for different amount of children. ## 0.18.0 - Fix unecessary errors around `fts5` tables - Merge all moor-specific nodes into a single `visitMoorSpecific` visitor method - Parse `BEGIN` and `COMMIT` statements - Improve type inference around `RETURNING` clauses. ## 0.17.2 - Fix nullability analysis of `COALESCE` and `IFNULL` ## 0.17.1 - Fix nullability analysis of references and star columns ## 0.17.0 - Refactor how tables and columns are resolved in statements - The new `ResultSetAvailableInStatement` class describes a result set that has been added to a statement, for instance through a from clause - A `TableOrSubquery` with an alias now introduces a `TableAlias` instead of the original table ## 0.16.0 - New analysis checks for `RETURNING`: Disallow `table.*` syntax and aggregate expressions - Support `RAISE` expressions in triggers - Fix resolving columns when `RETURNING` is used in an `UPDATE FROM` statement - Fix aliases to rowid being reported as nullable ## 0.15.0 - __Breaking__: Change `InsertStatement.upsert` to a list of upsert clauses - Support multiple upsert clauses - Do not require a conflict target in the last clause - Support `RETURNING` clauses in updates, deletes and inserts - Support `FROM` clauses in `UPDATE` statements - Support `MATERIALIZED`/`NOT MATERIALIZED` hints in common table expressions - Add `BuiltInMathExtension` which corresponds to the `-DSQLITE_ENABLE_MATH_FUNCTIONS` compile-time option for sqlite. - Add `EngineOptions.version` argument to specify the desired sqlite version. Using newer features will be reported as analysis warnings. - Fix `rank` columns of fts5 tables being misreported as integers ## 0.14.0 - Fix views using common table expressions ## 0.13.0-nullsafety.0 - Parse ordering in table key constraints - Deprecate `KeyClause.indexedColumns` in favor of `KeyClause.columns` ## 0.12.0-nullsafety.0 - Migrate to null-safety - Remove legacy type inference - Parser support for new moor features ## 0.11.0 - New `package:sqlparser/utils/node_to_text.dart` library that turns an AST node back into a textual representation. - Fix precedence of `CASE` expressions ## 0.10.1 - Scan identifiers with `[bracket syntax]` - `NumericToken` now contains individual lexemes making up the number - Improve error messages in some scenarios - Fix type inference for binary expressions where the operands have incompatible types - Improve type inference around `NULL` ## 0.10.0 - Breaking: Made `RecursiveVisitor.visit`, `visitList` and `visitExcept` an extension on `AstVisitor`. - Support the transformer pattern to modify ast nodes - Breaking: `FrameBoundary`, `DeleteTarget`, `UpdateTarget`, `DefaultValues` and `InsertTarget` are no longer constant - Breaking: Removed `visitQueryable`. Use `defaultQueryable` instead. - Support parsing and analyzing `CREATE VIEW` statements (see `SchemaFromCreateTable.readView`). Thanks to [@mqus](https://github.com/mqus) for their contribution! - `SqlEngine.parse` will no longer throw when there's a parsing error (use `ParseResult.errors` instead). - Parse `DEFERRABLE` clauses on foreign key constraints - Parse `NULLS FIRST` and `NULLS LAST` on `ORDER BY` terms ## 0.9.0 - New `package:sqlparser/utils/find_referenced_tables.dart` library. Use it to easily find all referenced tables in a query. - Support [row values](https://www.sqlite.org/rowvalue.html) including warnings about misuse ## 0.8.1 - Support collate expressions in the new type inference ([#533](htt ps://github.com/simolus3/moor/issues/533)) - Added `visitCollateExpression` to the visitor classes ## 0.8.0 - Remove `SqlEngine.withOptions` constructor - the default constructor now takes options - Changed `SelectStatement.from` from `List` to `Queryable?`. Selecting from multiple tables with a comma will now be parsed as a `JoinClause`. - Changed `SelectStatementAsSource.statement` from `SelectStatement` to `BaseSelectStatement` and allow compound select statements to appear in a `FROM` clause - Support the `VALUES` clause as select statement - The new type inference engine is now enabled by default and the `enableExperimentalTypeInference` option has been removed. To continue using the old engine, the `useLegacyTypeInference` flag can be used. ## 0.7.0 - New feature: Table valued functions. - __Breaking__: Removed the `enableJson1` parameter on `EngineOptions`. Add a `Json1Extension` instance to `enabledExtensions` instead. - Parse `rowid` as a valid reference when needed (`SELECT rowid FROM tbl` is now parsed correctly) - Parse `CURRENT_TIME`, `CURRENT_DATE` and `CURRENT_TIMESTAMP` - Parse `UPSERT` clauses for insert statements ## 0.6.0 - __Breaking:__ Added an argument type and argument to the visitor classes - Experimental new type inference algorithm (`SqlEngine.withOptions(EngineOptions(enableExperimentalTypeInference: true))`) - Support `CAST` expressions and the `ISNULL` / `NOTNULL` postfixes - Support parsing `CREATE TRIGGER` statements - Support parsing `CREATE INDEX` statements ## 0.5.0 - Optionally support the `json1` module - Optionally support the `fts5` module ## 0.4.0 - Support common table expressions - Handle special `rowid`, `oid`, `__rowid__` references - Support references to `sqlite_master` and `sqlite_sequence` tables ## 0.3.0 - parse compound select statements - scan comment tokens - experimental auto-complete engine (only supports a tiny subset based on the grammar only) - some features that are specific to moor __0.3.0+1__: Accept `\r` characters as whitespace ## 0.2.0 - Parse `CREATE TABLE` statements - Extract schema information from parsed create table statements with `SchemaFromCreateTable`. ## 0.1.2 - parse `COLLATE` expressions - fix wrong order in parsed `LIMIT` clauses ## 0.1.1 Attempt to recognize when a bound variable should be an array (eg. in `WHERE x IN ?`). Also fixes a number of parsing bugs: - Parses tuples, proper type resolution for `IN` expressions - Don't resolve references to tables that don't appear in the surrounding statement. - Parse joins without any additional operator, e.g. `table1 JOIN table2` instead of `table1 CROSS JOIN table2`. - Parser now complains when parsing a query doesn't fully consume the input ## 0.1.0 Initial version, can parse most statements but not `DELETE`, common table expressions and other advanced features.lib 755 0 0 0 0 6772 5ustar0 pubpublib/sqlparser.dart 644 0 0 1611 14711510426 12320 0ustar0 pubpub/// An sql parser and analyzer for Dart. library sqlparser; export 'src/analysis/analysis.dart'; export 'src/analysis/types/join_analysis.dart'; export 'src/ast/ast.dart'; export 'src/engine/module/dbstat.dart' show DbStatExtension; export 'src/engine/module/fts5.dart' show Fts5Extension, Fts5Table; export 'src/engine/module/geopoly.dart' show GeopolyExtension; export 'src/engine/module/json1.dart' show Json1Extension; export 'src/engine/module/math.dart' show BuiltInMathExtension; export 'src/engine/module/rtree.dart' show RTreeExtension; export 'src/engine/module/spellfix1.dart' show Spellfix1Extension; export 'src/engine/module/module.dart'; export 'src/engine/options.dart'; export 'src/engine/sql_engine.dart'; export 'src/reader/parser.dart' show ParsingError; export 'src/reader/syntactic_entity.dart'; export 'src/reader/tokenizer/token.dart' hide keywords, driftKeywords, isKeyword; lib/src 755 0 0 0 0 7561 5ustar0 pubpublib/src/engine 755 0 0 0 0 11026 5ustar0 pubpublib/src/engine/autocomplete 755 0 0 0 0 13527 5ustar0 pubpublib/src/engine/autocomplete/engine.dart 644 0 0 7206 14345646642 16331 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:sqlparser/sqlparser.dart'; part 'descriptions/description.dart'; part 'descriptions/references.dart'; part 'descriptions/static.dart'; part 'suggestion.dart'; /// Helper to provide context aware auto-complete suggestions inside a sql /// query. /// /// While parsing a query, the parser will yield a bunch of [Hint]s that are /// specific to a specific location. Each hint contains the current position and /// a [HintDescription] of what can appear behind that position. /// To obtain suggestions for a specific cursor position, we then go back from /// that position to the last [Hint] found and populate it. class AutoCompleteEngine { /// The found hints. UnmodifiableListView get foundHints => _hintsView; // hints are always sorted by their offset final List _hints = []; late final UnmodifiableListView _hintsView = UnmodifiableListView(_hints); final List _tokens; final SqlEngine _engine; void addHint(Hint hint) { if (_hints.isEmpty) { _hints.add(hint); } else { // ensure that the hints list stays sorted by offset final position = _lastHintBefore(hint.offset); final hintBefore = _hints[position]; // if we already have a hint at this position, merge them together if (hintBefore.before == hint.before) { hintBefore.description = hintBefore.description.mergeWith(hint.description); } else { _hints.insert(position + 1, hint); } } } AutoCompleteEngine(this._tokens, this._engine); /// Suggest completions at a specific [offset]. /// /// If the caller knows that autocomplete is requested in a CRUD statement /// that has been analyzed, providing the surrounding [context] can yield /// better results (for instance when completing column names). ComputedSuggestions suggestCompletions(int offset, [AnalysisContext? context]) { if (_hints.isEmpty) { return ComputedSuggestions(-1, -1, []); } final hint = foundHints[_lastHintBefore(offset)]; final suggestions = hint.description.suggest(CalculationRequest(_engine, context)).toList(); // when calculating the offset, respect whitespace that comes after the // last hint. final lastToken = hint.before; final nextToken = lastToken != null ? _tokens[lastToken.index + 1] : _tokens.first; final hintOffset = nextToken.span.start.offset; final length = offset - hintOffset; return ComputedSuggestions(hintOffset, length, suggestions); } /// find the last hint that appears before [offset] int _lastHintBefore(int offset) { var min = 0; var max = foundHints.length - 1; while (min < max) { final mid = min + ((max - min) >> 1); final hint = _hints[mid]; final offsetOfMid = hint.offset; if (offsetOfMid == offset) { return mid; } else { final offsetOfNext = _hints[mid + 1].offset; if (offsetOfMid < offset) { if (offsetOfNext > offset) { // next one is too late, so this must be the correct one return mid; } min = mid + 1; } else { max = mid - 1; } } } return min; } } class Hint { /// The token that appears just before this hint, or `null` if the hint /// appears at the beginning of the file. final Token? before; int get offset => before?.span.end.offset ?? 0; HintDescription description; Hint(this.before, this.description); } class CalculationRequest { final SqlEngine engine; final AnalysisContext? context; CalculationRequest(this.engine, [this.context]); } lib/src/engine/autocomplete/suggestion.dart 644 0 0 1754 14345646642 17255 0ustar0 pubpubpart of 'engine.dart'; /// The result of suggesting auto-complete at a specific location. class ComputedSuggestions { /// The offset from the source file from which the suggestion should be /// applied. Effectively, the range from [anchor] to `anchor + lengthBefore` /// will be replaced with the suggestion. final int anchor; /// The amount of chars that have already been typed and would be replaced /// when applying a suggestion. final int lengthBefore; /// The actual suggestions which are relevant here. final List suggestions; ComputedSuggestions(this.anchor, this.lengthBefore, this.suggestions); } /// A single auto-complete suggestion. class Suggestion { /// The code inserted. final String code; /// The relevance of this suggestion, where more relevant suggestions have a /// higher [relevance]. final int relevance; Suggestion(this.code, this.relevance); @override String toString() { return 'Suggestion($code, $relevance)'; } } lib/src/engine/autocomplete/descriptions 755 0 0 0 0 16235 5ustar0 pubpublib/src/engine/autocomplete/descriptions/description.dart 644 0 0 2436 14345646642 22115 0ustar0 pubpubpart of '../engine.dart'; /// Attached to a hint. A [HintDescription], together with additional context, /// can be used to compute the available autocomplete suggestions. abstract class HintDescription { const HintDescription(); const factory HintDescription.tokens(List types) = TokensDescription; factory HintDescription.token(TokenType type) = TokensDescription.single; Iterable suggest(CalculationRequest request); HintDescription mergeWith(HintDescription other) { return CombinedDescription() ..descriptions.add(this) ..descriptions.add(other); } } /// A [HintDescription] that bundles multiple independent [HintDescription]s. class CombinedDescription extends HintDescription { /// The descriptions to consult when using [suggest]. This list may be /// modified at runtime. final List descriptions = []; @override Iterable suggest(CalculationRequest request) { return descriptions.expand((s) => s.suggest(request)); } @override HintDescription mergeWith(HintDescription other) { if (other is CombinedDescription) { // optimization: flatten into single list descriptions.addAll(other.descriptions); } else { descriptions.add(other); } return this; } } lib/src/engine/autocomplete/descriptions/static.dart 644 0 0 1031 14345646642 21047 0ustar0 pubpubpart of '../engine.dart'; /// Suggestion that just inserts a bunch of token types with whitespace in /// between. class TokensDescription extends HintDescription { final List types; const TokensDescription(this.types); TokensDescription.single(TokenType type) : types = [type]; @override Iterable suggest(CalculationRequest request) sync* { final code = types .map((type) => reverseKeywords[type]) .where((k) => k != null) .join(' '); yield Suggestion(code, 0); } } lib/src/engine/autocomplete/descriptions/references.dart 644 0 0 630 14345646642 21665 0ustar0 pubpubpart of '../engine.dart'; /// Autocomplete hint to signal that a table name is expected. class TableNameDescription extends HintDescription { const TableNameDescription(); @override Iterable suggest(CalculationRequest request) { final tableNames = request.engine.knownResultSets.map((t) => t.escapedName); return tableNames.map((t) { return Suggestion(t, 1); }); } } lib/src/engine/sql_engine.dart 644 0 0 33554 14720702252 14517 0ustar0 pubpubimport 'dart:collection'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'autocomplete/engine.dart'; import 'builtin_tables.dart'; class SqlEngine { /// All tables registered with [registerTable]. final List knownResultSets = []; final List _knownModules = []; /// Internal options for this sql engine. final EngineOptions options; SchemaFromCreateTable? _schemaReader; SqlEngine([EngineOptions? engineOptions]) : options = engineOptions ?? EngineOptions() { for (final extension in options.enabledExtensions) { extension.register(this); } registerTable(sqliteMaster); // sqlite3_schema has been added in sqlite 3.33.0 as an alias to the master // table. Since 3.34.0 is the first version for which we have feature flags, // we just add it unconditionally. registerTable(sqliteSchema); registerTable(sqliteSequence); } /// Obtain a [SchemaFromCreateTable] instance compatible with the /// configuration of this engine. /// /// The returned reader can be used to read the table structure from a /// [TableInducingStatement] by using [SchemaFromCreateTable.read]. SchemaFromCreateTable get schemaReader { return _schemaReader ??= _createSchemaReader(null); } SchemaFromCreateTable _createSchemaReader( AnalyzeStatementOptions? stmtOptions) { final driftOptions = options.driftOptions; if (stmtOptions != null) { return SchemaFromCreateTable( driftExtensions: driftOptions != null, driftUseTextForDateTime: driftOptions?.storeDateTimesAsText == true, statementOptions: stmtOptions, ); } else { return _schemaReader ??= SchemaFromCreateTable( driftExtensions: driftOptions != null, driftUseTextForDateTime: driftOptions?.storeDateTimesAsText == true, ); } } /// Registers the [table], which means that it can later be used in sql /// statements. void registerTable(Table table) { registerResultSet(table); } /// Registers the [view], which means that it can later be used in sql /// statements. void registerView(View view) { registerResultSet(view); } /// Registers an arbitrary [namedResultSet], which means that it can later /// be used in sql statements. void registerResultSet(NamedResultSet namedResultSet) { knownResultSets.add(namedResultSet); } /// Registers the [module], which means that it can be used as a function in /// `CREATE VIRTUAL TABLE` statements. void registerModule(Module module) { _knownModules.add(module); } /// Registers the [handler], which can provide implementations for additional /// sql functions that can then be used in statements analyzed through this /// engine. void registerFunctionHandler(FunctionHandler handler) { options.addFunctionHandler(handler); } /// Registers the [handler], which can infer result sets for a table-valued /// function. void registerTableValuedFunctionHandler(TableValuedFunctionHandler handler) { options.addTableValuedFunctionHandler(handler); } RootScope _constructRootScope() { final scope = RootScope(); for (final resultSet in knownResultSets) { scope.knownTables[resultSet.name] = resultSet; } for (final module in _knownModules) { scope.knownModules[module.name] = module; } return scope; } Scanner _scan(String source) { final scanner = Scanner(source, scanDriftTokens: options.useDriftExtensions); return scanner..scanTokens(); } /// Tokenizes the [source] into a list list [Token]s. Each [Token] contains /// information about where it appears in the [source] and a [TokenType]. /// /// If an error occurs while tokenizing, e.g. because an invalid token is /// found, throws a [CumulatedTokenizerException]. /// /// Note that the list might be tokens that should be /// [Token.invisibleToParser], if you're passing them to a [Parser] directly, /// you need to filter them. When using the methods in this class, this will /// be taken care of automatically. List tokenize(String source) { final scanner = _scan(source); if (scanner.errors.isNotEmpty) { throw CumulatedTokenizerException(scanner.errors); } return scanner.tokens; } (List, Parser, AutoCompleteEngine?) _createParser( String source, { bool autoComplete = false, bool? driftExtensions, }) { final tokenizer = _scan(source); final allTokens = tokenizer.tokens; final tokensForParser = allTokens.where((t) => !t.invisibleToParser).toList(); final autoCompleteEngine = autoComplete ? AutoCompleteEngine(allTokens, this) : null; final parser = Parser( tokensForParser, useDrift: driftExtensions ?? options.useDriftExtensions, autoComplete: autoCompleteEngine, ); for (final error in tokenizer.errors) { parser.errors.add(ParsingError(error, error.message)); } return (allTokens, parser, autoCompleteEngine); } /// Parses a single [sql] statement into an AST-representation. /// /// This method generally doesn't throw, but instead collects parsing errors /// through [ParseResult.errors]. Callers should check that value instead of /// blindly trusting the returned AST, as it will be an approximation if /// parsing errors were encountered. ParseResult parse(String sql) { final (tokens, parser, _) = _createParser(sql); final stmt = parser.safeStatement(); return ParseResult._(stmt, tokens, parser.errors, sql, null); } /// Parses multiple [sql] statements, separated by a semicolon. /// /// You can use the [AstNode.childNodes] of the returned [ParseResult.rootNode] /// to inspect the returned statements. /// /// This method generally doesn't throw, but instead collects parsing errors /// through [ParseResult.errors]. Callers should check that value instead of /// blindly trusting the returned AST, as it will be an approximation if /// parsing errors were encountered. ParseResult parseMultiple(String sql) { final (tokens, parser, _) = _createParser(sql); final ast = parser.safeStatements(); return ParseResult._(ast, tokens, parser.errors, sql, null); } /// Parses [sql] as a list of column constraints. /// /// The [ParseResult.rootNode] will be a [ColumnDefinition] with the parsed /// constraints. /// /// This method generally doesn't throw, but instead collects parsing errors /// through [ParseResult.errors]. Callers should check that value instead of /// blindly trusting the returned AST, as it will be an approximation if /// parsing errors were encountered. ParseResult parseColumnConstraints(String sql) { final (tokens, parser, _) = _createParser(sql, driftExtensions: false); return ParseResult._( ColumnDefinition( columnName: '', typeName: '', constraints: parser.columnConstraintsUntilEnd(), ), tokens, parser.errors, sql, null, ); } /// Parses [sql] as a single table constraint. /// /// The [ParseResult.rootNode] will either be a [TableConstraint] or an /// [InvalidStatement] in case of parsing errors. /// /// This method generally doesn't throw, but instead collects parsing errors /// through [ParseResult.errors]. Callers should check that value instead of /// blindly trusting the returned AST, as it will be an approximation if /// parsing errors were encountered. ParseResult parseTableConstraint(String sql) { final (tokens, parser, _) = _createParser(sql, driftExtensions: false); AstNode? constraint; try { constraint = parser.tableConstraintOrNull(requireConstraint: true); } on ParsingError { // Ignore, will be added to parser.errors anyway } return ParseResult._( constraint ?? InvalidStatement(), tokens, parser.errors, sql, null, ); } /// Parses a `.drift` file, which can consist of multiple statements and /// additional components like import statements. ParseResult parseDriftFile(String content) { assert(options.useDriftExtensions); final (tokens, parser, autoComplete) = _createParser(content, autoComplete: true); final driftFile = parser.driftFile(); driftFile.scope = _constructRootScope(); return ParseResult._( driftFile, tokens, parser.errors, content, autoComplete); } /// Parses and analyzes the [sql] statement. The [AnalysisContext] returned /// contains all information about type hints, errors, and the parsed AST. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyze(String sql, {AnalyzeStatementOptions? stmtOptions}) { final result = parse(sql); final analyzed = analyzeParsed(result, stmtOptions: stmtOptions); // Add parsing errors that occurred at the beginning since they are the most // prominent problems. analyzed.errors.insertAll(0, result.errors.map(AnalysisError.fromParser)); return analyzed; } /// Analyzes a parsed [result] statement. The [AnalysisContext] returned /// contains all information about type hints, errors, and the parsed AST. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyzeParsed(ParseResult result, {AnalyzeStatementOptions? stmtOptions}) { final node = result.rootNode; return analyzeNode(node, result.sql, stmtOptions: stmtOptions); } /// Analyzes the given [node], which should be a [CrudStatement]. /// The [AnalysisContext] enhances the AST by reporting type hints and errors. /// The [file] should contain the full SQL source code that was used to parse /// the [node]. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyzeNode(AstNode node, String file, {AnalyzeStatementOptions? stmtOptions}) { final context = _createContext(node, file, stmtOptions); _analyzeContext(context); return context; } AnalysisContext _createContext( AstNode node, String sql, AnalyzeStatementOptions? stmtOptions) { final schemaSupport = _createSchemaReader(stmtOptions); return AnalysisContext(node, sql, _constructRootScope(), options, stmtOptions: stmtOptions, schemaSupport: schemaSupport); } void _analyzeContext(AnalysisContext context) { final node = context.root; node.scope = context.rootScope; AstPreparingVisitor(context: context).start(node); node ..accept(ColumnResolver(context), const ColumnResolverContext()) ..accept(ReferenceResolver(context), const ReferenceResolvingContext()); final session = TypeInferenceSession(context, options); final resolver = TypeResolver(session); resolver.run(node); context.types2 = session.results!; node.acceptWithoutArg(LintingVisitor(options, context)); } } /// The result of parsing an sql query. Contains the root of the AST and all /// errors that might have occurred during parsing. class ParseResult { /// The topmost node in the sql AST that was parsed. final AstNode rootNode; /// The tokens that were scanned in the source file, including those that are /// [Token.invisibleToParser]. final List tokens; /// A list of all errors that occurred during parsing. [ParsingError.toString] /// returns a helpful description of what went wrong, along with the position /// where the error occurred. final List errors; /// The sql source that created the AST at [rootNode]. final String sql; /// The engine which can be used to handle auto-complete requests on this /// result. final AutoCompleteEngine? autoCompleteEngine; ParseResult._(this.rootNode, this.tokens, this.errors, this.sql, this.autoCompleteEngine) { const SetParentVisitor().startAtRoot(rootNode); } /// Attempts to find the most relevant (bottom-most in the AST) nodes that /// intersects with the source range from [offset] to [offset] + [length]. List findNodesAtPosition(int offset, {int length = 0}) { if (tokens.isEmpty) return const []; final candidates = {}; final unchecked = Queue(); unchecked.add(rootNode); while (unchecked.isNotEmpty) { final node = unchecked.removeFirst(); final span = node.span!; final start = span.start.offset; final end = span.end.offset; final hasIntersection = !(end < offset || start > offset + length); if (hasIntersection) { // this node matches. As we want to find the bottom-most node in the AST // that matches, this means that the parent is no longer a candidate. candidates.add(node); candidates.remove(node.parent); // assume that the span of a node is a superset of the span of any // child, so each child could potentially be interesting. unchecked.addAll(node.childNodes); } } return candidates.toList(); } /// Returns the lexeme that created an AST [node] (which should be a child of /// [rootNode], e.g appear in this result). String lexemeOfNode(AstNode node) { return sql.substring(node.firstPosition, node.lastPosition); } } lib/src/engine/builtin_tables.dart 644 0 0 2224 14711510426 15341 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; /// Constructs the "sqlite_sequence" table. Table get sqliteSequence { final name = TableColumn('name', const ResolvedType(type: BasicType.text)); final seq = TableColumn('seq', const ResolvedType(type: BasicType.int)); return Table(name: 'sqlite_sequence', resolvedColumns: [name, seq]); } /// Constructs the "sqlite_master" table Table get sqliteMaster { final type = TableColumn('type', const ResolvedType(type: BasicType.text)); final name = TableColumn('name', const ResolvedType(type: BasicType.text)); final tblName = TableColumn('tbl_name', const ResolvedType(type: BasicType.text)); final rootPage = TableColumn('rootpage', const ResolvedType(type: BasicType.int)); final sql = TableColumn('sql', const ResolvedType(type: BasicType.text)); return Table( name: 'sqlite_master', resolvedColumns: [type, name, tblName, rootPage, sql], ); } /// Constructs the "sqlite_schema" table, which is identical to "sqlite_master" /// after sqlite version 3.33.0 Table get sqliteSchema { return Table( name: 'sqlite_schema', resolvedColumns: sqliteMaster.resolvedColumns, ); } lib/src/engine/module 755 0 0 0 0 12313 5ustar0 pubpublib/src/engine/module/spellfix1.dart 644 0 0 3426 14345646642 15557 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class Spellfix1Extension implements Extension { const Spellfix1Extension(); @override void register(SqlEngine engine) { engine.registerModule(_Spellfix1Module()); } } class _Spellfix1Module extends Module { _Spellfix1Module() : super('spellfix1'); @override Table parseTable(CreateVirtualTableStatement stmt) { return Table( name: stmt.tableName, resolvedColumns: [ TableColumn('word', const ResolvedType(type: BasicType.text)), TableColumn( 'rank', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn('distance', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn('langid', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn( 'score', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn('matchlen', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn( 'top', const ResolvedType(type: BasicType.int), isHidden: true, ), TableColumn( 'scope', const ResolvedType(type: BasicType.int), isHidden: true, ), TableColumn( 'srchcnt', const ResolvedType(type: BasicType.int), isHidden: true, ), TableColumn( 'soundslike', const ResolvedType(type: BasicType.text), isHidden: true, ), TableColumn( 'command', const ResolvedType(type: BasicType.int), isHidden: true, ), ], definition: stmt, isVirtual: true); } } lib/src/engine/module/json1.dart 644 0 0 10227 14711507160 14703 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class Json1Extension implements Extension { const Json1Extension(); @override void register(SqlEngine engine) { final supportsJsonb = engine.options.version >= SqliteVersion.v3_45; engine ..registerFunctionHandler(_Json1Functions(supportsJsonb)) ..registerTableValuedFunctionHandler(const _JsonEachFunction()) ..registerTableValuedFunctionHandler(const _JsonTreeFunction()); } } class _Json1Functions implements FunctionHandler { final bool _supportBinaryJson; const _Json1Functions(this._supportBinaryJson); static const Set _returnStrings = { 'json', 'json_array', 'json_insert', 'json_replace', 'json_set', 'json_object', 'json_patch', 'json_pretty', 'json_remove', 'json_quote', 'json_group_array', 'json_group_object', }; static const Set _returnBlobs = { 'jsonb', 'jsonb_array', 'jsonb_insert', 'jsonb_object', 'jsonb_patch', 'jsonb_remove', 'jsonb_replace', 'jsonb_set', 'jsonb_group_array', 'jsonb_group_object' }; @override Set get functionNames => { ..._returnStrings, if (_supportBinaryJson) ..._returnBlobs, 'json_type', 'json_valid', 'json_extract', if (_supportBinaryJson) 'jsonb_extract', 'json_array_length', }; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { return const ResolveResult.unknown(); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { final name = call.name.toLowerCase(); if (_returnStrings.contains(name)) { return const ResolveResult(ResolvedType(type: BasicType.text)); } else if (_returnBlobs.contains(name)) { return const ResolveResult(ResolvedType(type: BasicType.blob)); } else { switch (name) { case 'json_type': return const ResolveResult( ResolvedType(type: BasicType.text, nullable: true)); case 'json_valid': return const ResolveResult(ResolvedType.bool()); case 'json_extract': case 'jsonb_extract': return const ResolveResult.needsContext(); case 'json_array_length': return const ResolveResult(ResolvedType(type: BasicType.int)); } } throw AssertionError("Can't happen, unknown json1 function"); } @override void reportErrors(SqlInvocation call, AnalysisContext context) { if (context.engineOptions.version < SqliteVersion.v3_46 && call.name.toLowerCase() == 'json_pretty') { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'json_pretty requires sqlite 3.46.0 or later.', relevantNode: call.nameToken ?? call, )); } } } final _jsonFunctionResultSet = CustomResultSet([ // https://www.sqlite.org/json1.html#the_json_each_and_json_tree_table_valued_functions // we use string for any TableColumn('key', const ResolvedType(type: BasicType.text)), TableColumn( 'value', const ResolvedType(type: BasicType.text, nullable: true)), TableColumn('type', const ResolvedType(type: BasicType.text)), TableColumn('atom', const ResolvedType(type: BasicType.text)), TableColumn('type', const ResolvedType(type: BasicType.text)), TableColumn('id', const ResolvedType(type: BasicType.int)), TableColumn( 'parent', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn('fullkey', const ResolvedType(type: BasicType.text)), ]); abstract class _JsonTableValuedFunction implements TableValuedFunctionHandler { const _JsonTableValuedFunction(); @override ResultSet resolveTableValued( AnalysisContext context, TableValuedFunction call) { return _jsonFunctionResultSet; } } class _JsonEachFunction extends _JsonTableValuedFunction { const _JsonEachFunction(); @override String get functionName => 'json_each'; } class _JsonTreeFunction extends _JsonTableValuedFunction { const _JsonTreeFunction(); @override String get functionName => 'json_tree'; } lib/src/engine/module/module.dart 644 0 0 10273 14704536051 15142 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; /// Interface for sqlite extensions providing additional functions or module. /// /// Extension support in the sqlparser package is still experimental, and only /// supports modules for `CREATE VIRTUAL TABLE` statements at the moment. abstract class Extension { void register(SqlEngine engine); } /// Function handlers can be implemented by an [Extension] to add type analysis /// for additional function. abstract class FunctionHandler { /// Constant default constructor to allow const implementations. const FunctionHandler(); /// The set of function names supported by this handler. /// /// The returned set shouldn't change over time. Set get functionNames; /// Resolve the return type of a function invocation. /// /// The [call] refers to a function declared in [functionNames]. To provide /// further analysis, the [context] may be used. To support function calls /// with a [StarFunctionParameter], [expandedArgs] contains the expanded /// arguments from a `function(*)` call. /// /// If resolving to a type isn't possible, implementations should return /// [ResolveResult.unknown]. ResolveResult inferReturnType( AnalysisContext context, SqlInvocation call, List expandedArgs); /// Resolve the type of an argument used in a function invocation. /// /// The [call] refers to a function declared in [functionNames]. To provide /// further analysis, the [context] may be used. This method should return /// the inferred type of [argument], which is an argument passed to the /// [call]. /// /// If resolving to a type isn't possible, implementations should return /// [ResolveResult.unknown]. ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument); /// Can optionally be used by implementations to provide [AnalysisError]s /// from the [call]. /// /// Errors should be reported via [AnalysisContext.reportError]. void reportErrors(SqlInvocation call, AnalysisContext context) {} } /// Should be mixed on on [FunctionHandler] implementations only. mixin ArgumentCountLinter { /// Returns the amount of arguments expected for [function] (lowercase). /// /// If the function is unknown, or if the result would be ambiguous, returns /// null. int? argumentCountFor(String function); int actualArgumentCount(SqlInvocation call) { return call.expandParameters().length; } void reportMismatches(SqlInvocation call, AnalysisContext context) { final expectedArgs = argumentCountFor(call.name.toLowerCase()); if (expectedArgs != null) { final actualArgs = actualArgumentCount(call); if (actualArgs != expectedArgs) { reportArgumentCountMismatch(call, context, expectedArgs, actualArgs); } } } void reportArgumentCountMismatch( SqlInvocation call, AnalysisContext context, int? expected, int actual) { context.reportError(AnalysisError( relevantNode: call, message: '${call.name} expects $expected arguments, ' 'got $actual.', type: AnalysisErrorType.other, )); } } /// Interface for a handler which can resolve the result set of a table-valued /// function. abstract class TableValuedFunctionHandler { /// The name of the table-valued function implemented by this handler. String get functionName; /// Resolve the result set of a table-valued function. /// /// Should return null when the result set can't be resolved. /// /// See also: /// - https://www.sqlite.org/vtab.html#tabfunc2 ResultSet resolveTableValued( AnalysisContext context, TableValuedFunction call); } /// An sqlite module, which can be used in a `CREATE VIRTUAL TABLE` statement /// to find providers. abstract class Module implements Referencable { /// The name of this module, which is referenced by the `USING` clause in a /// `CREATE VIRTUAL TABLE` statement. final String name; Module(this.name); /// Extracts the table structure from a `CREATE VIRTUAL TABLE` statement that /// refers to this module. The module is responsible for setting /// [Table.definition]. Table parseTable(CreateVirtualTableStatement stmt); @override bool get visibleToChildren => true; } lib/src/engine/module/fts5.dart 644 0 0 22464 14711507160 14540 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class Fts5Extension implements Extension { const Fts5Extension(); @override void register(SqlEngine engine) { engine.registerModule(_Fts5Module()); engine.registerModule(_Fts5VocabModule()); engine.registerFunctionHandler(const _Fts5Functions()); } } /// FTS5 module for `CREATE VIRTUAL TABLE USING fts5` support class _Fts5Module extends Module { static final RegExp _option = RegExp(r'^(.+)\s*=\s*(.+)$'); static final RegExp _cleanTicks = RegExp('[\'"]'); _Fts5Module() : super('fts5'); @override Table parseTable(CreateVirtualTableStatement stmt) { final columnNames = []; final options = {}; for (final argument in stmt.argumentContent) { // arguments with an equals sign are parameters passed to the fts5 module. // they're not part of the schema. final match = _option.firstMatch(argument); if (match == null) { // actual syntax is columnNames.add(argument.trim().split(' ').first); } else { options[match.group(1)!.replaceAll(_cleanTicks, '')] = match.group(2)!.replaceAll(_cleanTicks, ''); } } //No external content when null or empty String final contentTable = (options['content']?.isNotEmpty ?? false) ? options['content'] : null; //Fallback to "rowid" when option is not set final contentRowId = options['content_rowid'] ?? 'rowid'; return Fts5Table( name: stmt.tableName, contentTable: contentTable, contentRowId: (contentTable != null) ? contentRowId : null, columns: [ for (var arg in columnNames) TableColumn(arg, const ResolvedType(type: BasicType.text)), ], definition: stmt, ); } } class _Fts5VocabModule extends Module { _Fts5VocabModule() : super('fts5vocab'); @override Table parseTable(CreateVirtualTableStatement stmt) { if (stmt.argumentContent.length < 2 || stmt.argumentContent.length > 3) { throw ArgumentError( 'fts5vocab table requires at least two arguments ' '(, ) and maximum three arguments ' 'when using an attached database', ); } final type = stmt.argumentContent.last.replaceAll(RegExp(r'''["' ]'''), ''); switch (type) { case 'row': return Table( name: stmt.tableName, resolvedColumns: [ TableColumn('term', const ResolvedType(type: BasicType.text)), TableColumn('doc', const ResolvedType(type: BasicType.int)), TableColumn('cnt', const ResolvedType(type: BasicType.int)), ], definition: stmt, isVirtual: true); case 'col': return Table( name: stmt.tableName, resolvedColumns: [ TableColumn('term', const ResolvedType(type: BasicType.text)), TableColumn('col', const ResolvedType(type: BasicType.text)), TableColumn('doc', const ResolvedType(type: BasicType.int)), TableColumn('cnt', const ResolvedType(type: BasicType.int)), ], definition: stmt, isVirtual: true); case 'instance': return Table( name: stmt.tableName, resolvedColumns: [ TableColumn('term', const ResolvedType(type: BasicType.text)), TableColumn('doc', const ResolvedType(type: BasicType.int)), TableColumn('col', const ResolvedType(type: BasicType.text)), TableColumn('offset', const ResolvedType(type: BasicType.int)), ], definition: stmt, isVirtual: true); default: throw ArgumentError('Unknown fts5vocab table type'); } } } class Fts5Table extends Table { final String? contentTable; final String? contentRowId; Fts5Table({ required super.name, required List columns, this.contentTable, this.contentRowId, CreateVirtualTableStatement? super.definition, }) : super( resolvedColumns: [ if (contentTable != null && contentRowId != null) RowId(), ...columns, _Fts5RankColumn(), _Fts5TableColumn(name), ], isVirtual: true, ); } /// Provides type inference and lints for class _Fts5Functions with ArgumentCountLinter implements FunctionHandler { const _Fts5Functions(); @override Set get functionNames => const {'bm25', 'highlight', 'snippet'}; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { int? argumentIndex; if (call.parameters is ExprFunctionParameters) { argumentIndex = (call.parameters as ExprFunctionParameters) .parameters .indexOf(argument); } if (argumentIndex == null || argumentIndex < 0) { // couldn't find expression in arguments, so we don't know the type return const ResolveResult.unknown(); } switch (call.name) { case 'bm25': // bm25(fts_table, weights...) if (argumentIndex == 0) { return const ResolveResult.unknown(); } else { return const ResolveResult(ResolvedType(type: BasicType.real)); } case 'highlight': // highlight(fts_table, column_index, text_before, text_after) if (argumentIndex == 1) { return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (argumentIndex == 2 || argumentIndex == 3) { return const ResolveResult(ResolvedType(type: BasicType.text)); } break; case 'snippet': // snippet(fts_table, column_index, phrase_before, phrase_after, // text_before, max_tokens) if (argumentIndex == 1 || argumentIndex == 5) { return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (argumentIndex >= 2 || argumentIndex <= 4) { return const ResolveResult(ResolvedType(type: BasicType.text)); } break; } return const ResolveResult.unknown(); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { switch (call.name.toLowerCase()) { case 'bm25': return const ResolveResult(ResolvedType(type: BasicType.real)); case 'highlight': case 'snippet': return const ResolveResult(ResolvedType(type: BasicType.text)); } return const ResolveResult.unknown(); } @override int? argumentCountFor(String function) { return const { 'highlight': 4, 'snippet': 6, }[function]; } @override void reportErrors(SqlInvocation call, AnalysisContext context) { // it doesn't make sense to call fts5 functions with a star parameter if (call.parameters is StarFunctionParameter) { context.reportError(AnalysisError( relevantNode: call, message: '${call.name} should not be called with a star parameter', type: AnalysisErrorType.other, )); return; } final args = (call.parameters as ExprFunctionParameters).parameters; final calledFunction = call.name.toLowerCase(); final expectedArgCount = argumentCountFor(calledFunction); if (expectedArgCount != null && expectedArgCount != args.length) { reportArgumentCountMismatch(call, context, expectedArgCount, args.length); return; } Column? firstResolved; if (args.first is Reference) { firstResolved = (args.first as Reference).resolvedColumn; } // the first argument to all functions must be a fts5 table name if (firstResolved == null || firstResolved.source is! _Fts5TableColumn) { context.reportError(AnalysisError( relevantNode: args.first, message: 'Expected an fts5 table name here', type: AnalysisErrorType.other, )); } else if (calledFunction == 'bm25') { // The bm25 function can use (table, weights...) parameters, but there // shouldn't be more weights than columns. final source = firstResolved.source as _Fts5TableColumn; if (source.table case final table?) { if (args.length > table.resultColumns.length + 1) { context.reportError(AnalysisError( relevantNode: call, message: 'Superfluous weight columns (there are only ' '${table.resultColumns.length} columns on the table).', type: AnalysisErrorType.other, )); } } } } } /// The rank column, which we introduce to support queries like /// ``` /// SELECT * FROM my_fts_table WHERE my_fts_table MATCH 'foo' ORDER BY rank; /// ``` class _Fts5RankColumn extends TableColumn { @override bool get includedInResults => false; _Fts5RankColumn() : super('rank', const ResolvedType(type: BasicType.real, nullable: true)); } /// A column that has the same name as the fts5 it's from. We introduce this /// column to support constructs like /// ``` /// CREATE VIRTUAL TABLE foo USING fts5(bar, baz); /// query: SELECT * FROM foo WHERE foo MATCH 'something'; /// ``` /// The easiest way to support that is to just make "foo" a column on that /// table. class _Fts5TableColumn extends TableColumn { @override bool get includedInResults => false; _Fts5TableColumn(String name) : super(name, const ResolvedType(type: BasicType.text)); } lib/src/engine/module/rtree.dart 644 0 0 2302 14345646642 14761 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class RTreeExtension implements Extension { const RTreeExtension(); @override void register(SqlEngine engine) { engine.registerModule(_RTreeModule()); } } class _RTreeModule extends Module { _RTreeModule() : super('rtree'); @override Table parseTable(CreateVirtualTableStatement stmt) { final columnNames = stmt.argumentContent; if (columnNames.length < 3 || columnNames.length > 11) { throw ArgumentError( 'An rtree virtual table is supposed to have between 3 and 11 columns'); } if (columnNames.length.isEven) { throw ArgumentError( 'The rtree has not been initialized with a proper dimension. ' 'Required is an index, followed by a even number of min/max pairs'); } return Table(name: stmt.tableName, resolvedColumns: [ for (final columnName in columnNames) //First column is always an integer primary key //followed by n floating point values (columnName == columnNames.first) ? TableColumn(columnName, const ResolvedType(type: BasicType.int)) : TableColumn(columnName, const ResolvedType(type: BasicType.real)) ]); } } lib/src/engine/module/dbstat.dart 644 0 0 4670 14711510426 15116 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; /// Provides static analysis support for the `DBSTAT` sqlite3 table. /// /// The DBSTAT virtual table is a read-only eponymous virtual table that returns /// information about the amount of disk space used to store the content of an /// SQLite database. class DbStatExtension implements Extension { const DbStatExtension(); @override void register(SqlEngine engine) { engine.registerTable(_dbstat); } } /// The DBSTAT virtual table is a read-only eponymous virtual table that returns /// information about the amount of disk space used to store the content of an /// SQLite database. Table get _dbstat { /// Name of table or index final name = TableColumn('name', const ResolvedType(type: BasicType.text)); /// Path to page from root final path = TableColumn('path', const ResolvedType(type: BasicType.text)); /// Page number, or page count final pageno = TableColumn('pageno', const ResolvedType(type: BasicType.int)); /// 'internal', 'leaf', 'overflow', or NULL final pagetype = TableColumn('pagetype', const ResolvedType(type: BasicType.text)); /// Cells on page (0 for overflow pages) final ncell = TableColumn('ncell', const ResolvedType(type: BasicType.int)); /// Bytes of payload on this page or btree final payload = TableColumn('payload', const ResolvedType(type: BasicType.int)); /// Bytes of unused space on this page or btree final unused = TableColumn('unused', const ResolvedType(type: BasicType.int)); /// Bytes of unused space on this page or btree final mxPayload = TableColumn('mx_payload', const ResolvedType(type: BasicType.int)); /// Byte offset of the page in the database file final pgoffset = TableColumn('pgoffset', const ResolvedType(type: BasicType.int)); /// Size of the page, in bytes final pgsize = TableColumn('pgsize', const ResolvedType(type: BasicType.int)); /// Database schema being analyzed final schema = TableColumn('schema', const ResolvedType(type: BasicType.text), isHidden: true); /// True to enable aggregate mode final aggregate = TableColumn( 'aggregate', const ResolvedType(type: BasicType.int), isHidden: true); return Table( name: 'dbstat', isVirtual: true, resolvedColumns: [ name, path, pageno, pagetype, ncell, payload, unused, mxPayload, pgoffset, pgsize, schema, aggregate, ], ); } lib/src/engine/module/math.dart 644 0 0 6136 14345646642 14602 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/options.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'module.dart'; /// A math extension providing functions built into sqlite. /// /// This is an extension since it's only available when sqlite 3.35 is used /// together with the `-DSQLITE_ENABLE_MATH_FUNCTIONS` compile-time option. class BuiltInMathExtension implements Extension { const BuiltInMathExtension(); @override void register(SqlEngine engine) { if (engine.options.version < SqliteVersion.v3_35) { throw StateError('The math extension is only available with ' 'sqlite3 version 35 or later'); } engine.registerFunctionHandler(const _MathFunctions()); } } class _MathFunctions extends FunctionHandler { const _MathFunctions(); static const _constants = { 'pi', }; static const _unary = { 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'degrees', 'exp', 'ln', 'log', // note that log is also binary 'log10', 'log2', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', }; static const _unaryToInt = { 'ceil', 'ceiling', 'floor', 'trunc', }; static const _binary = { 'atan2', 'pow', 'power', 'mod', }; @override Set get functionNames => const {..._constants, ..._unary, ..._unaryToInt, ..._binary}; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { return const ResolveResult(ResolvedType(type: BasicType.real)); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { if (_unaryToInt.contains(call.name.toLowerCase())) { return const ResolveResult(ResolvedType(type: BasicType.int)); } return const ResolveResult(ResolvedType(type: BasicType.real)); } @override void reportErrors(SqlInvocation call, AnalysisContext context) { final name = call.name.toLowerCase(); final argumentCount = call.expandParameters().length; // log can be called with one or two arguments if (name == 'log') { if (argumentCount != 1 && argumentCount != 2) { context.reportError(AnalysisError( relevantNode: call, message: 'log requires one or two arguments, got $argumentCount', type: AnalysisErrorType.other, )); } return; } int expectedArgs; if (_constants.contains(name)) { expectedArgs = 0; } else if (_unary.contains(name) || _unaryToInt.contains(name)) { expectedArgs = 1; } else if (_binary.contains(name)) { expectedArgs = 2; } else { return; // Can't say how many args are required } if (expectedArgs != argumentCount) { context.reportError(AnalysisError( relevantNode: call, message: '$name requires $expectedArgs arguments, got $argumentCount', type: AnalysisErrorType.other, )); } } } lib/src/engine/module/geopoly.dart 644 0 0 15263 14656673450 15352 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/module/module.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; final class GeopolyExtension implements Extension { const GeopolyExtension(); @override void register(SqlEngine engine) { engine ..registerModule(_GeopolyModule(engine)) ..registerFunctionHandler(_GeopolyFunctionHandler()); } } const String _shapeKeyword = '_shape'; const ResolvedType _typePolygon = ResolvedType( type: BasicType.blob, nullable: true, hints: [ IsGeopolyPolygon(), ], ); final class _GeopolyModule extends Module { _GeopolyModule(this.engine) : super('geopoly'); final SqlEngine engine; @override Table parseTable(CreateVirtualTableStatement stmt) { final resolvedColumns = [ RowId(), TableColumn( _shapeKeyword, _typePolygon, ), ]; for (final column in stmt.argumentContent) { final tokens = engine.tokenize(column); final String resolvedName; final ResolvedType resolvedType; switch (tokens) { // geoID INTEGER not null case [final name, final type, final not, final $null, final eof] when name.type == TokenType.identifier && type.type == TokenType.identifier && not.type == TokenType.not && $null.type == TokenType.$null && eof.type == TokenType.eof: resolvedName = name.lexeme; resolvedType = engine.schemaReader .resolveColumnType(type.lexeme) .withNullable(false); // a INTEGER case [final name, final type, final eof] when name.type == TokenType.identifier && type.type == TokenType.identifier && eof.type == TokenType.eof: resolvedName = name.lexeme; resolvedType = engine.schemaReader .resolveColumnType(type.lexeme) .withNullable(true); // b case [final name, final eof] when name.type == TokenType.identifier && eof.type == TokenType.eof: resolvedName = name.lexeme; resolvedType = const ResolvedType( type: BasicType.any, nullable: true, ); // ? default: throw ArgumentError('Can\'t be parsed', column); } resolvedColumns.add( TableColumn( resolvedName, resolvedType, ), ); } return Table( name: stmt.tableName, resolvedColumns: resolvedColumns, definition: stmt, isVirtual: true, ); } } final class _GeopolyFunctionHandler extends FunctionHandler { @override Set get functionNames => { for (final value in _GeopolyFunctions.values) value.sqlName, }; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument, ) { // TODO(nikitadol): Copy from `_Fts5Functions`. Must be removed when argument index appears int? argumentIndex; if (call.parameters is ExprFunctionParameters) { argumentIndex = (call.parameters as ExprFunctionParameters) .parameters .indexOf(argument); } if (argumentIndex == null || argumentIndex < 0) { // couldn't find expression in arguments, so we don't know the type return const ResolveResult.unknown(); } // final func = _GeopolyFunctions.bySqlName(call.name); if (argumentIndex < func.args.length) { return ResolveResult(func.args[argumentIndex]); } else if (func.otherArgs != null) { return ResolveResult(func.otherArgs); } else { return ResolveResult.unknown(); } } @override ResolveResult inferReturnType( AnalysisContext context, SqlInvocation call, List expandedArgs, ) { final func = _GeopolyFunctions.bySqlName(call.name); if (expandedArgs.length == func.args.length) { // ok } else if (expandedArgs.length > func.args.length && func.otherArgs != null) { // ok } else { final buffer = StringBuffer( 'The function `${func.sqlName}` takes ', ); buffer.write('${func.args.length} '); switch (func.args.length) { case 1: buffer.write('argument'); case > 1: buffer.write('arguments'); } if (func.otherArgs != null) { buffer.write(' (or more)'); } buffer.write(' but ${expandedArgs.length} '); switch (expandedArgs.length) { case 1: buffer.write('argument is'); case > 1: buffer.write('arguments are'); } buffer.write('passed'); throw ArgumentError(buffer); } return ResolveResult( func.returnType, ); } } const _typeInt = ResolvedType( type: BasicType.int, nullable: true, ); const _typeReal = ResolvedType( type: BasicType.real, nullable: true, ); const _typeBlob = ResolvedType( type: BasicType.blob, nullable: true, ); const _typeText = ResolvedType( type: BasicType.text, nullable: true, ); enum _GeopolyFunctions { overlap( 'geopoly_overlap', _typeInt, [_typePolygon, _typePolygon], ), within( 'geopoly_within', _typeInt, [_typePolygon, _typePolygon], ), area( 'geopoly_area', _typeReal, [_typePolygon], ), blob( 'geopoly_blob', _typeBlob, [_typePolygon], ), json( 'geopoly_json', _typeText, [_typePolygon], ), svg( 'geopoly_svg', _typeText, [_typePolygon], _typeText, ), bbox( 'geopoly_bbox', _typeBlob, [_typePolygon], ), groupBbox( 'geopoly_group_bbox', _typeBlob, [_typePolygon], ), containsPoint( 'geopoly_contains_point', _typeInt, [_typePolygon, _typeInt, _typeInt], ), xform( 'geopoly_xform', _typeBlob, [ _typePolygon, _typeReal, _typeReal, _typeReal, _typeReal, _typeReal, _typeReal ], ), regular( 'geopoly_regular', _typeBlob, [_typeReal, _typeReal, _typeReal, _typeInt], ), ccw( 'geopoly_ccw', _typeBlob, [_typePolygon], ); final String sqlName; final ResolvedType returnType; final List args; final ResolvedType? otherArgs; const _GeopolyFunctions( this.sqlName, this.returnType, this.args, [ this.otherArgs, ]); factory _GeopolyFunctions.bySqlName(String sqlName) { return _GeopolyFunctions.values.firstWhere( (element) => element.sqlName == sqlName, orElse: () => throw ArgumentError('$sqlName not exists')); } } lib/src/engine/options.dart 644 0 0 13730 14656673450 14077 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:sqlparser/sqlparser.dart'; class EngineOptions { /// If drift extensions are enabled, contains options on how to interpret /// drift-specific syntax. /// /// Drift extends the sql grammar a bit to support type converters and other /// features. Enabling this flag will make this engine parse sql with these /// extensions enabled. final DriftSqlOptions? driftOptions; /// The target sqlite version. /// /// This library will report analysis errors when using features there weren't /// available in the targeted [version]. /// Defaults to [SqliteVersion.minimum]. final SqliteVersion version; /// All [Extension]s that have been enabled in this sql engine. final List enabledExtensions; final List _addedFunctionHandlers = []; /// A map from lowercase function names to the associated handler. final Map addedFunctions = {}; /// A map from lowercase function names (where the function is a table-valued /// function) to the associated handler. final Map addedTableFunctions = {}; bool get useDriftExtensions => driftOptions != null; EngineOptions({ this.driftOptions, List enabledExtensions = const [], this.version = SqliteVersion.minimum, }) : enabledExtensions = _allExtensions(enabledExtensions, version) { if (version < SqliteVersion.minimum) { throw ArgumentError.value( version, 'version', 'Must at least be ${SqliteVersion.minimum}'); } if (version > SqliteVersion.current) { throw ArgumentError.value( version, 'version', 'Must at most be ${SqliteVersion.current}'); } } static List _allExtensions( List added, SqliteVersion version) { return [ // The json1 extension was enabled by default in sqlite3 version 3.38, so // add it if it's not already enabled. if (version >= SqliteVersion.v3_38 && !added.any((e) => e is Json1Extension)) const Json1Extension(), ...added, ]; } void addFunctionHandler(FunctionHandler handler) { _addedFunctionHandlers.add(handler); for (final function in handler.functionNames) { addedFunctions[function.toLowerCase()] = handler; } } void addTableValuedFunctionHandler(TableValuedFunctionHandler handler) { addedTableFunctions[handler.functionName.toLowerCase()] = handler; } } /// Drift-specific parsing and analysis options that are not enabled by default. class DriftSqlOptions { final bool storeDateTimesAsText; const DriftSqlOptions({ this.storeDateTimesAsText = false, }); } /// The assumed version of `sqlite3`. /// /// This library can provide analysis hints when using sqlite features newer /// than the desired version. @sealed class SqliteVersion implements Comparable { /// The minimum sqlite version assumed by the current version of the /// `sqlparser` package. /// /// This does not mean that older version aren't supported, but this library /// can't provide analysis warnings when using recent sqlite3 features. static const SqliteVersion minimum = SqliteVersion.v3(34); /// Version `3.46.0` added `json_pretty` and allows underscore characters /// between digits in numeric literals. static const SqliteVersion v3_46 = SqliteVersion.v3(46); /// Version `3.45.0` has added support for a binary JSON format and introduces /// `jsonb` variants of JSON functions. static const SqliteVersion v3_45 = SqliteVersion.v3(45); /// Version `3.44.0` has added `ORDER BY` clauses as parameters for aggregate /// functions and more SQL functions. static const SqliteVersion v3_44 = SqliteVersion.v3(44); /// Version `3.43.0` added the built-in `timediff` and `octet_length` /// functions. static const SqliteVersion v3_43 = SqliteVersion.v3(43); /// Version `3.41.0` added the built-in `unhex` function. static const SqliteVersion v3_41 = SqliteVersion.v3(41); /// Version `3.39.0` of `sqlite3`. /// /// New language features include `RIGHT` / `FULL OUTER JOIN` and `IS DISTINCT /// FROM`. static const SqliteVersion v3_39 = SqliteVersion.v3(39); /// Version `3.38.0` of `sqlite3`. static const SqliteVersion v3_38 = SqliteVersion.v3(38); /// Version `3.37.0` of `sqlite3`. static const SqliteVersion v3_37 = SqliteVersion.v3(37); /// Version `3.35.0` of `sqlite3`. static const SqliteVersion v3_35 = SqliteVersion.v3(35); /// The highest sqlite version supported by this `sqlparser` package. /// /// Newer features in `sqlite3` may not be recognized by this library. static const SqliteVersion current = v3_46; /// The major version of sqlite. /// /// This will always be `3` in the foreseeable future. final int major; /// The minor version of sqlite. /// /// sqlite version `3.34.0` would have a minor version of `34`. final int minor; /// The patch version of sqlite. /// /// sqlite version `3.34.1` would have a minor version of `1`. final int patch; const SqliteVersion(this.major, this.minor, this.patch); const SqliteVersion.v3(int minor, [int patch = 0]) : this(3, minor, patch); bool operator <(SqliteVersion other) => compareTo(other) < 0; bool operator >(SqliteVersion other) => compareTo(other) > 0; bool operator >=(SqliteVersion other) => compareTo(other) >= 0; @override int compareTo(SqliteVersion other) { if (major != other.major) return major.compareTo(other.major); if (minor != other.minor) return minor.compareTo(other.minor); if (patch != other.patch) return patch.compareTo(other.patch); return 0; } @override int get hashCode => major * minor * patch; @override bool operator ==(Object other) { return identical(this, other) || other is SqliteVersion && other.major == major && other.minor == minor && other.patch == patch; } @override String toString() { return 'SqliteVersion($major, $minor, $patch)'; } } lib/src/reader 755 0 0 0 0 11023 5ustar0 pubpublib/src/reader/recovery.dart 644 0 0 3607 14711507160 14203 0ustar0 pubpub@internal library; import 'package:meta/meta.dart'; import 'tokenizer/token.dart'; /// An active error recovery context in the parser. /// /// The current error recovery context is represented as a stack of /// [ErrorRecoveryScope]s. /// When an error is encountered, the parser skips tokens until [indicatesEnd] /// returns true on any recovery scope. sealed class ErrorRecoveryScope { /// Whether [token] indicates the end of this error recovery scope, meaning /// that we can stop a synchronization run here. bool indicatesEnd(Token token); } /// An error recovery scope used when parsing statements. It will skip over to /// the next semicolon when we have an unrecoverable error in the statement so /// that we can at least parse subsequent statements. final class InStatement implements ErrorRecoveryScope { const InStatement(); @override bool indicatesEnd(Token token) { return token.type == TokenType.semicolon; } } /// An error recovery scope used for elements separated by comma. /// /// When encountering an error parsing an element, we can skip to the next comma /// and attempt to parse other elements to recover a larger part of the AST. final class InCommaSeparatedList implements ErrorRecoveryScope { @override bool indicatesEnd(Token token) { return token.type == TokenType.comma; } } /// An error recovery scope used for things in parentheses. /// /// When encountering an error inside the parentheses, we can skip to the /// matching closing parenthesis if it has been inferred via [Token.match] in /// the scanner. This mainly avoids skipping too much when no other precise /// scope is active. final class InParentheses implements ErrorRecoveryScope { final Token leftParentheses; final Token? rightParenthesis; InParentheses(this.leftParentheses, this.rightParenthesis); @override bool indicatesEnd(Token token) { return token == rightParenthesis; } } lib/src/reader/syntactic_entity.dart 644 0 0 4600 14345646642 15750 0ustar0 pubpubimport 'package:source_span/source_span.dart'; /// Interface for entities that appear in a piece of text. As far as the /// parser is concerned, this contains tokens and ast nodes. abstract class SyntacticEntity { /// Whether this entity has a source span associated with it. bool get hasSpan; /// The piece of text forming this syntactic entity. FileSpan? get span; /// The first position of this entity, as an zero-based offset in the file it /// was read from. /// /// Instead of returning null, this getter may throw for entities where /// [hasSpan] is false. int get firstPosition; /// The (exclusive) last index of this entity in the source. /// /// Instead of returning null, this getter may throw for entities where /// [hasSpan] is false. int get lastPosition; /// Whether this entity is synthetic, meaning that it doesn't appear in the /// actual source. bool get synthetic; } /// Extension to report the length of a [SyntacticEntity]. extension SyntacticLengthExtension on SyntacticEntity { /// The length of this entity, in characters. int get length => lastPosition - firstPosition; } /// Extension to obtain the span for a sequence of [SyntacticEntity]. extension UnionEntityExtension on Iterable { /// Creates the span covered by all of the entities in this iterable. FileSpan get span { if (isEmpty) { throw ArgumentError.value(this, 'this', 'Was empty'); } final firstSpan = first.span; return skip(1).fold( firstSpan!, (previousValue, entity) => previousValue.expand(entity.span!), ); } /// Returns the common [span] of these syntactic entities, or `null` if the /// iterable is empty. FileSpan? get spanOrNull { return isEmpty ? null : span; } /// Returns a single [SyntacticEntity] representing this range of entities. SyntacticEntity get toSingleEntity => _UnionSyntacticEntity(toList()); } class _UnionSyntacticEntity extends SyntacticEntity { final List _members; _UnionSyntacticEntity(this._members); @override int get firstPosition => _members.first.firstPosition; @override bool get hasSpan => _members.any((entity) => entity.hasSpan); @override int get lastPosition => _members.last.lastPosition; @override FileSpan? get span => _members.spanOrNull; @override bool get synthetic => _members.every((entity) => entity.synthetic); } lib/src/reader/parser.dart 644 0 0 262171 14712224414 13703 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:source_span/source_span.dart'; import '../ast/ast.dart'; import '../engine/autocomplete/engine.dart'; import 'recovery.dart'; import 'tokenizer/token.dart'; const _comparisonOperators = [ TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, ]; const _binaryOperators = [ TokenType.shiftLeft, TokenType.shiftRight, TokenType.ampersand, TokenType.pipe, ]; class ParsingError implements Exception { final Token token; final String message; ParsingError(this.token, this.message); @override String toString() { return token.span.message('Error: $message'); } } class Parser { final List tokens; final List errors = []; final AutoCompleteEngine? autoComplete; /// Whether to enable the extensions drift makes to the sql grammar. final bool enableDriftExtensions; int _current = 0; final List _errorRecovery = []; Parser(this.tokens, {bool useDrift = false, this.autoComplete}) : enableDriftExtensions = useDrift; bool get _reportAutoComplete => autoComplete != null; void _suggestHint(HintDescription description) { final tokenBefore = _current == 0 ? null : _previous; autoComplete?.addHint(Hint(tokenBefore, description)); } void _suggestHintForTokens(Iterable types) { final relevant = types.where(isKeyword).map(HintDescription.token); final description = CombinedDescription()..descriptions.addAll(relevant); _suggestHint(description); } void _suggestHintForToken(TokenType type) { if (isKeyword(type)) { _suggestHint(HintDescription.token(type)); } } bool get _isAtEnd => _peek.type == TokenType.eof; Token get _peek => tokens[_current]; Token? get _peekNext { if (_isAtEnd) return null; return tokens[_current + 1]; } Token get _previous => tokens[_current - 1]; bool _match(Iterable types) { if (_reportAutoComplete) _suggestHintForTokens(types); for (final type in types) { if (_check(type)) { _advance(); return true; } } return false; } bool _matchOne(TokenType type) { if (_reportAutoComplete) _suggestHintForToken(type); if (_check(type)) { _advance(); return true; } return false; } Token? _matchOneAndGet(TokenType type) { if (_matchOne(type)) { return _previous; } return null; } /// Returns true if the next token is [type] or if the next two tokens are /// "NOT" followed by [type]. Does not consume any tokens. bool _checkWithNot(TokenType type) { if (_check(type)) return true; if (_check(TokenType.not) && _peekNext?.type == type) return true; return false; } /// Like [_checkWithNot], but with more than one token type. bool _checkAnyWithNot(List types) { if (types.any(_check)) return true; if (_check(TokenType.not) && types.contains(_peekNext?.type)) return true; return false; } bool _check(TokenType type) { if (_reportAutoComplete) _suggestHintForToken(type); if (_isAtEnd) return false; return _peek.type == type; } bool _checkAny(Iterable type) { if (_isAtEnd) return false; return type.contains(_peek.type); } /// Returns whether the next token is an [TokenType.identifier] or a /// [KeywordToken]. If this method returns true, calling [_consumeIdentifier] /// with same [lenient] parameter will now throw. bool _checkIdentifier({bool lenient = false}) { final next = _peek; if (next.type == TokenType.identifier) return true; return next is KeywordToken && (next.canConvertToIdentifier() || lenient); } Token _advance() { if (!_isAtEnd) { _current++; } return _previous; } Never _error(String message) { final error = ParsingError(_peek, message); errors.add(error); throw error; } Token _consume(TokenType type, [String? message]) { if (_check(type)) return _advance(); _error(message ?? 'Expected $type'); } /// Consumes an identifier. IdentifierToken _consumeIdentifier(String message, {bool lenient = false}) { final next = _peek; // non-standard keywords can be parsed as an identifier, we allow all // keywords when lenient is true if (next is KeywordToken && (next.canConvertToIdentifier() || lenient)) { return (_advance() as KeywordToken).convertToIdentifier(); } if (next is KeywordToken) { message = '$message (got keyword ${reverseKeywords[next.type]})'; } return _consume(TokenType.identifier, message) as IdentifierToken; } /// Parses a statement without throwing when there's a parsing error. Statement safeStatement() { return _parseAsStatement(statement, requireSemicolon: false) ?? InvalidStatement(); } SemicolonSeparatedStatements safeStatements() { final first = _peek; final statements = []; while (!_isAtEnd) { final firstForStatement = _peek; final statement = _parseAsStatement(_statementWithoutSemicolon); if (statement != null) { statements.add(statement); } else { statements .add(InvalidStatement()..setSpan(firstForStatement, _previous)); } } return SemicolonSeparatedStatements(statements)..setSpan(first, _previous); } /// Parses the remaining input as column constraints. List columnConstraintsUntilEnd() { final constraints = []; try { while (!_isAtEnd) { constraints.add(_columnConstraint()!); } } on ParsingError { // ignore, it's also logged in [errors] } return constraints; } Statement _statementWithoutSemicolon() { if (_checkAny(const [ TokenType.$with, TokenType.select, TokenType.$values, TokenType.delete, TokenType.update, TokenType.insert, TokenType.replace, ])) { return _crud()!; } if (_check(TokenType.create)) { return _create()!; } if (_check(TokenType.begin)) { return _beginStatement(); } if (_checkAny(const [TokenType.commit, TokenType.end])) { return _commit(); } if (enableDriftExtensions) { if (_check(TokenType.import)) { return _import()!; } if (_check(TokenType.identifier) || _peek is KeywordToken) { return _declaredStatement()!; } } _error('Expected a sql statement to start here'); } Statement statement() { final first = _peek; final stmt = _statementWithoutSemicolon(); if (_matchOne(TokenType.semicolon)) { stmt.semicolon = _previous; } if (!_isAtEnd) { _error('Expected the statement to finish here'); } return stmt..setSpan(first, _previous); } DriftFile driftFile() { final first = _peek; final foundComponents = []; while (!_isAtEnd) { foundComponents.add(_parseAsStatement(_partOfDriftFile)); } foundComponents.removeWhere((c) => c == null); final file = DriftFile(foundComponents.cast()); if (foundComponents.isNotEmpty) { file.setSpan(first, _previous); } else { _suggestHintForTokens([TokenType.create, TokenType.import]); file.setSpan(first, first); // empty file } return file; } PartOfDriftFile _partOfDriftFile() { final found = _import() ?? _create() ?? _declaredStatement(); if (found != null) { return found; } _error('Expected `IMPORT`, `CREATE`, or an identifier starting a compiled ' 'query.'); } ImportStatement? _import() { if (_matchOne(TokenType.import)) { final importToken = _previous; final import = _consume(TokenType.stringLiteral, 'Expected import file as a string literal (single quoted)') as StringLiteralToken; return ImportStatement(import.value) ..importToken = importToken ..importString = import; } return null; } DeclaredStatement? _declaredStatement() { DeclaredStatementIdentifier identifier; if (_check(TokenType.identifier) || _peek is KeywordToken) { final name = _consumeIdentifier('Expected a name for a declared query', lenient: true); identifier = SimpleName(name.identifier)..identifier = name; } else if (_matchOne(TokenType.atSignVariable)) { final previous = _previous as AtSignVariableToken; identifier = SpecialStatementIdentifier(previous.name) ..nameToken = previous; } else { return null; } final parameters = []; if (_matchOne(TokenType.leftParen)) { do { parameters.add(_statementParameter()); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing parenthesis'); } final as = _driftTableName(); final colon = _consume( TokenType.colon, 'Expected a colon (:) followed by a query. Imports and CREATE ' 'statements must appear before the first query.'); AstNode? stmt; if (_check(TokenType.begin)) { stmt = _transactionBlock(); } else { stmt = _crud(); } if (stmt == null) { _error( 'Expected a sql statement here (SELECT, UPDATE, INSERT or DELETE)'); } return DeclaredStatement( identifier, stmt, parameters: parameters, as: as, )..colon = colon; } StatementParameter _statementParameter() { final first = _peek; final isRequired = _matchOne(TokenType.required); final variable = _variableOrNull(); if (variable != null) { // Type hint for a variable Token? as; String? typeName; if (_matchOne(TokenType.as)) { as = _previous; final typeNameTokens = _typeName() ?? _error('Expected a type name here'); typeName = typeNameTokens.lexeme; } var orNull = false; if (_matchOne(TokenType.or)) { _consume(TokenType.$null, 'Expected NULL to finish OR NULL'); orNull = true; } return VariableTypeHint(variable, typeName, orNull: orNull, isRequired: isRequired) ..as = as ..setSpan(first, _previous); } else if (_matchOne(TokenType.dollarSignVariable)) { final placeholder = _previous as DollarSignVariableToken; _consume(TokenType.equal, 'Expected an equals sign here'); final defaultValue = expression(); return DartPlaceholderDefaultValue(placeholder.name, defaultValue) ..setSpan(placeholder, _previous) ..variableToken = placeholder; } else { _error('Expected a variable or a Dart placeholder here'); } } void _withErrorRecovery(ErrorRecoveryScope scope, void Function() inner) { _errorRecovery.add(scope); try { inner(); } on ParsingError { while (!_isAtEnd) { final next = _peek; final leftScope = _errorRecovery.lastWhereOrNull((scope) => scope.indicatesEnd(next)); if (leftScope == null) { _advance(); continue; } if (leftScope != scope) { rethrow; // The parent error recovery handler needs to deal with this. } else { break; } } } finally { final removed = _errorRecovery.removeLast(); assert(identical(removed, scope)); } } /// Invokes [parser], sets the appropriate source span and attaches a /// semicolon if one exists. T? _parseAsStatement(T? Function() parser, {bool requireSemicolon = true}) { final first = _peek; T? result; _withErrorRecovery(const InStatement(), () { result = parser(); }); if (_matchOne(TokenType.semicolon)) { result?.semicolon = _previous; result?.setSpan(first, _previous); } else if (result != null && requireSemicolon) { try { result!.semicolon = _consume(TokenType.semicolon, 'Expected a semicolon after the statement ended'); } on ParsingError { // Ignore } } return result; } List _crudStatements(bool Function() reachedEnd) { final stmts = []; while (!reachedEnd()) { final stmt = _parseAsStatement(_crud); if (stmt != null) { stmts.add(stmt); } else { _error('Invalid statement, expected SELECT, INSERT, UPDATE or DELETE.'); } } return stmts; } /// Parses a block, which consists of statements between `BEGIN` and `END`. Block _consumeBlock() { final begin = _consume(TokenType.begin, 'Expected BEGIN'); final stmts = _crudStatements(() => _check(TokenType.end)); final end = _consume(TokenType.end, 'Expected END'); return Block(stmts) ..setSpan(begin, end) ..begin = begin ..end = end; } TransactionBlock _transactionBlock() { final first = _peek; final begin = _beginStatement(); final stmts = _crudStatements( () => _checkAny(const [TokenType.commit, TokenType.end])); final end = _commit(); return TransactionBlock(begin: begin, innerStatements: stmts, commit: end) ..setSpan(first, _previous); } Expression expression() { return _or(); } /// Parses an expression of the form a b, where is in [types] and /// both a and b are expressions with a higher precedence parsed from /// [higherPrecedence]. Expression _parseSimpleBinary( List types, Expression Function() higherPrecedence) { var expression = higherPrecedence(); while (_match(types)) { final operator = _previous; final right = higherPrecedence(); expression = BinaryExpression(expression, operator, right) ..setSpan(expression.first!, _previous); } return expression; } Expression _or() => _parseSimpleBinary(const [TokenType.or], _and); Expression _and() => _parseSimpleBinary(const [TokenType.and], _in); Expression _in() { final left = _equals(); if (_checkWithNot(TokenType.$in)) { final not = _matchOne(TokenType.not); _matchOne(TokenType.$in); InExpressionTarget inside; if (_variableOrNull() case var variable?) { inside = variable; } else if (_check(TokenType.leftParen)) { inside = _consumeTuple(orSubQuery: true) as InExpressionTarget; } else { final target = _tableOrSubquery(allowAlias: false); // TableOrSubquery is either a table reference, a table-valued function, // or a Subquery. We don't support subqueries, but they can't be parsed // here because we would have entered the tuple case above. assert(target is! SubQuery); inside = target as InExpressionTarget; } return InExpression(left: left, inside: inside, not: not) ..setSpan(left.first!, _previous); } return left; } /// Parses expressions with the "equals" precedence. This contains /// comparisons, "IS (NOT) IN" expressions, between expressions and "like" /// expressions. Expression _equals() { var expression = _comparison(); final first = expression.first; const ops = [ TokenType.equal, TokenType.doubleEqual, TokenType.exclamationEqual, TokenType.lessMore, TokenType.$is, ]; const stringOps = [ TokenType.like, TokenType.glob, TokenType.match, TokenType.regexp, ]; for (;;) { if (_checkWithNot(TokenType.between)) { final not = _matchOne(TokenType.not); _consume(TokenType.between, 'expected a BETWEEN'); final lower = _comparison(); _consume(TokenType.and, 'expected AND'); final upper = _comparison(); expression = BetweenExpression( not: not, check: expression, lower: lower, upper: upper) ..setSpan(first!, _previous); } else if (_match(ops)) { final operator = _previous; if (operator.type == TokenType.$is) { final isToken = _previous; final not = _matchOne(TokenType.not); // Ansi sql `DISTINCT FROM` syntax introduced by sqlite 3.39 var distinctFrom = false; Token? distinct, from; if (_matchOne(TokenType.distinct)) { distinct = _previous; from = _consume(TokenType.from, 'Expected DISTINCT FROM'); distinctFrom = true; } expression = IsExpression(not, expression, _comparison(), distinctFromSyntax: distinctFrom) ..setSpan(first!, _previous) ..$is = isToken ..distinct = distinct ..from = from; } else { expression = BinaryExpression(expression, operator, _comparison()) ..setSpan(first!, _previous); } } else if (_checkAnyWithNot(stringOps)) { final not = _matchOne(TokenType.not); _match(stringOps); // will consume, existence was verified with check final operator = _previous; final right = _comparison(); Expression? escape; if (_matchOne(TokenType.escape)) { escape = _comparison(); } expression = StringComparisonExpression( not: not, left: expression, operator: operator, right: right, escape: escape) ..setSpan(first!, _previous); } else { break; // no matching operator with this precedence was found } } return expression; } Expression _comparison() { return _parseSimpleBinary(_comparisonOperators, _binaryOperation); } Expression _binaryOperation() { return _parseSimpleBinary(_binaryOperators, _addition); } Expression _addition() { return _parseSimpleBinary(const [ TokenType.plus, TokenType.minus, ], _multiplication); } Expression _multiplication() { return _parseSimpleBinary(const [ TokenType.star, TokenType.slash, TokenType.percent, ], _concatenation); } Expression _concatenation() { return _parseSimpleBinary(const [ TokenType.doublePipe, TokenType.dashRangle, TokenType.dashRangleRangle ], _unary); } Expression _unary() { if (_match(const [ TokenType.minus, TokenType.plus, TokenType.tilde, TokenType.not, ])) { final operator = _previous; final expression = _unary(); return UnaryExpression(operator, expression) ..setSpan(operator, expression.last!); } else if (_matchOne(TokenType.exists)) { final existsToken = _previous; _consume( TokenType.leftParen, 'Expected opening parenthesis after EXISTS'); final selectStmt = _fullSelect() ?? _error('Expected a select statement'); _consume(TokenType.rightParen, 'Expected closing paranthesis to finish EXISTS expression'); return ExistsExpression(select: selectStmt) ..setSpan(existsToken, _previous); } return _postfix(); } Expression _postfix() { var expression = _prefix(); final firstToken = expression.first; // todo we don't currently parse "NOT NULL" (2 tokens) because of ambiguity // with NOT BETWEEN / NOT IN / ... expressions const matchedTokens = [ TokenType.collate, TokenType.notNull, TokenType.isNull ]; while (_match(matchedTokens)) { final operator = _previous; switch (operator.type) { case TokenType.collate: final collateOp = _previous; final collateFun = _consume(TokenType.identifier, 'Expected a collating sequence') as IdentifierToken; expression = CollateExpression( inner: expression, operator: collateOp, collateFunction: collateFun, ); break; case TokenType.isNull: expression = IsNullExpression(expression); break; case TokenType.notNull: expression = IsNullExpression(expression, true); break; default: // we checked with _match, this may never happen throw AssertionError(); } expression.setSpan(firstToken ?? operator, _previous); } return expression; } Expression _prefix() { if (_matchOne(TokenType.$case)) { final caseToken = _previous; final base = _check(TokenType.when) ? null : _primary(); final whens = []; Expression? $else; while (_matchOne(TokenType.when)) { final whenToken = _previous; final whenExpr = _or(); _consume(TokenType.then, 'Expected THEN'); final then = expression(); whens.add(WhenComponent(when: whenExpr, then: then) ..setSpan(whenToken, _previous)); } if (_matchOne(TokenType.$else)) { $else = expression(); } _consume(TokenType.end, 'Expected END to finish the case operator'); return CaseExpression(whens: whens, base: base, elseExpr: $else) ..setSpan(caseToken, _previous); } else if (_matchOne(TokenType.raise)) { final raiseToken = _previous; _consume(TokenType.leftParen, 'Expected a left parenthesis after RAISE'); RaiseKind kind; const tokenToRaiseKind = { TokenType.ignore: RaiseKind.ignore, TokenType.rollback: RaiseKind.rollback, TokenType.abort: RaiseKind.abort, TokenType.fail: RaiseKind.fail, }; if (_match(tokenToRaiseKind.keys)) { kind = tokenToRaiseKind[_previous.type]!; } else { _error('Expected IGNORE, ROLLBACK, ABORT or FAIL here'); } String? message; if (kind != RaiseKind.ignore) { _consume(TokenType.comma, 'Expected a comma here'); final messageToken = _consume(TokenType.stringLiteral, 'Expected an error message here') as StringLiteralToken; message = messageToken.value; } final end = _consume( TokenType.rightParen, 'Expected a right parenthesis to finish RAISE'); return RaiseExpression(kind, message)..setSpan(raiseToken, end); } return _primary(); } Literal? _literalOrNull() { final token = _peek; Literal? parseInner() { if (_check(TokenType.numberLiteral)) { return _numericLiteral(); } if (_matchOne(TokenType.stringLiteral)) { token as StringLiteralToken; return StringLiteral(token.value, isBinary: token.binary) ..token = token; } if (_matchOne(TokenType.$null)) { return NullLiteral()..token = token; } if (_matchOne(TokenType.$true)) { return BooleanLiteral(true)..token = token; } if (_matchOne(TokenType.$false)) { return BooleanLiteral(false)..token = token; } const timeLiterals = { TokenType.currentTime: TimeConstantKind.currentTime, TokenType.currentDate: TimeConstantKind.currentDate, TokenType.currentTimestamp: TimeConstantKind.currentTimestamp, }; if (_match(timeLiterals.keys)) { final token = _previous; return TimeConstantLiteral(timeLiterals[token.type]!)..token = token; } return null; } final literal = parseInner(); literal?.setSpan(token, token); return literal; } NumericLiteral _numericLiteral() { final number = _consume(TokenType.numberLiteral, 'Expected a number here') as NumericToken; return NumericLiteral(number.parsedNumber) ..token = number ..setSpan(number, number); } Expression _primary() { final literal = _literalOrNull(); if (literal != null) return literal; final variable = _variableOrNull(); if (variable != null) return variable; if (_matchOne(TokenType.leftParen)) { final left = _previous; final selectStmt = _fullSelect(); // returns null if there's no select if (selectStmt != null) { _consume(TokenType.rightParen, 'Expected a closing bracket'); return SubQuery(select: selectStmt)..setSpan(left, _previous); } else { final expr = expression(); if (_matchOne(TokenType.comma)) { // It's a row value! final expressions = [expr]; do { expressions.add(expression()); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected a closing bracket'); return Tuple(expressions: expressions, usedAsRowValue: true) ..setSpan(left, _previous); } _consume(TokenType.rightParen, 'Expected a closing bracket'); return Parentheses(expr) ..openingLeft = left ..closingRight = _previous ..setSpan(left, _previous); } } else if (_matchOne(TokenType.dollarSignVariable)) { if (enableDriftExtensions) { final typedToken = _previous as DollarSignVariableToken; return DartExpressionPlaceholder(name: typedToken.name) ..token = typedToken ..setSpan(_previous, _previous); } } else if (_matchOne(TokenType.cast)) { final first = _previous; _consume(TokenType.leftParen, 'Expected opening parenthesis after CAST'); final operand = expression(); _consume(TokenType.as, 'Expected AS operator here'); final type = _typeName()!; final typeName = type.lexeme; _consume(TokenType.rightParen, 'Expected closing bracket here'); return CastExpression(operand, typeName)..setSpan(first, _previous); } else if (_checkIdentifier()) { return _referenceOrFunctionCall(); } if (_peek is KeywordToken) { // Improve error messages for possible function calls, https://github.com/simolus3/drift/discussions/2277 if (tokens.length > _current + 1 && _peekNext?.type == TokenType.leftParen) { _error( 'Expected an expression here, but got a reserved keyword. Did you ' 'mean to call a function? Try wrapping the keyword in double quotes.', ); } else { _error( 'Expected an expression here, but got a reserved keyword. Did you ' 'mean to use it as a column? Try wrapping it in double quotes ' '("${_peek.lexeme}").', ); } } else { _error('Could not parse this expression'); } } Expression _referenceOrFunctionCall() { final first = _consumeIdentifier( 'This error message should never be displayed. Please report.'); // An expression starting with an identifier could be three things: // - a simple reference: "foo" // - a reference with a table: "foo.bar" // - a reference with a table and a schema: "foo.bar.baz" // - a function call: "foo()" if (_matchOne(TokenType.dot)) { // Ok, we're down to two here. it's either a table or a schema ref final second = _consumeIdentifier('Expected a column or table name here', lenient: true); if (_matchOne(TokenType.dot)) { // Three identifiers, that's a schema reference final third = _consumeIdentifier('Expected a column name here', lenient: true); return Reference( schemaName: first.identifier, entityName: second.identifier, columnName: third.identifier, )..setSpan(first, third); } else { // Two identifiers only, so we have a table-based reference return Reference( entityName: first.identifier, columnName: second.identifier, )..setSpan(first, second); } } else if (_matchOne(TokenType.leftParen)) { // We have something like "foo(" -> that's a function! final parameters = _functionParameters(); // Aggregate functions can use `ORDER BY` in their argument list. final orderBy = _orderBy(); final rightParen = _consume( TokenType.rightParen, 'Expected closing bracket after argument list'); if (orderBy != null || _peek.type == TokenType.filter || _peek.type == TokenType.over) { return _aggregate(first, parameters, orderBy); } return FunctionExpression(name: first.identifier, parameters: parameters) ..nameToken = first ..setSpan(first, rightParen); } else { // Ok, just a regular reference then return Reference(columnName: first.identifier)..setSpan(first, first); } } Variable? _variableOrNull() { if (_matchOne(TokenType.questionMarkVariable)) { final token = _previous as QuestionMarkVariableToken; return NumberedVariable(token.explicitIndex) ..token = token ..setSpan(token, token); } else if (_matchOne(TokenType.colonVariable)) { return ColonNamedVariable(_previous as ColonVariableToken) ..setSpan(_previous, _previous); } return null; } /// Parses function parameters, without the surrounding parentheses. FunctionParameters _functionParameters() { if (_matchOne(TokenType.star)) { return StarFunctionParameter() ..starToken = _previous ..setSpan(_previous, _previous); } if (_check(TokenType.rightParen)) { // nothing between the brackets -> empty parameter list. We mark it as // synthetic because it has an empty span in the file return ExprFunctionParameters(parameters: const [])..synthetic = true; } final distinct = _matchOneAndGet(TokenType.distinct); final parameters = []; final first = _peek; do { parameters.add(expression()); } while (_matchOne(TokenType.comma)); return ExprFunctionParameters( distinct: distinct != null, parameters: parameters) ..distinctKeyword = distinct ..setSpan(first, _previous); } AggregateFunctionInvocation _aggregate( IdentifierToken name, FunctionParameters params, OrderByBase? orderBy, ) { Expression? filter; // https://www.sqlite.org/syntax/filter.html (it's optional) if (_matchOne(TokenType.filter)) { _consume(TokenType.leftParen, 'Expected opening parenthesis after filter statement'); _consume(TokenType.where, 'Expected WHERE clause'); filter = expression(); _consume(TokenType.rightParen, 'Expecteded closing parenthes'); } if (_matchOne(TokenType.over)) { String? windowName; WindowDefinition? window; if (_matchOne(TokenType.identifier)) { windowName = (_previous as IdentifierToken).identifier; } else { window = _windowDefinition(); } return WindowFunctionInvocation( function: name, parameters: params, orderBy: orderBy, filter: filter, windowDefinition: window, windowName: windowName, )..setSpan(name, _previous); } else { return AggregateFunctionInvocation( function: name, parameters: params, orderBy: orderBy, filter: filter, )..setSpan(name, _previous); } } /// Parses a [Tuple]. If [orSubQuery] is set (defaults to false), a [SubQuery] /// (in brackets) will be accepted as well. If parsing a [Tuple], [usedAsRowValue] is /// passed into the [Tuple] constructor. Expression _consumeTuple( {bool orSubQuery = false, bool usedAsRowValue = false}) { final firstToken = _consume(TokenType.leftParen, 'Expected opening parenthesis for tuple'); final expressions = []; // if desired, attempt to parse select statement final subQuery = orSubQuery ? _fullSelect() : null; if (subQuery == null) { // no sub query found. read expressions that form the tuple. // tuples can be empty `()`, so only start parsing values when it's not if (_peek.type != TokenType.rightParen) { do { expressions.add(expression()); } while (_matchOne(TokenType.comma)); } _consume( TokenType.rightParen, 'Expected right parenthesis to close tuple'); return Tuple(expressions: expressions, usedAsRowValue: usedAsRowValue) ..setSpan(firstToken, _previous); } else { _consume(TokenType.rightParen, 'Expected right parenthesis to finish subquery'); return SubQuery(select: subQuery)..setSpan(firstToken, _previous); } } BeginTransactionStatement _beginStatement() { final begin = _consume(TokenType.begin); Token? modeToken; var mode = TransactionMode.none; if (_match( const [TokenType.deferred, TokenType.immediate, TokenType.exclusive])) { modeToken = _previous; switch (modeToken.type) { case TokenType.deferred: mode = TransactionMode.deferred; break; case TokenType.immediate: mode = TransactionMode.immediate; break; case TokenType.exclusive: mode = TransactionMode.exclusive; break; default: throw AssertionError('unreachable'); } } Token? transaction; if (_matchOne(TokenType.transaction)) { transaction = _previous; } return BeginTransactionStatement(mode) ..setSpan(begin, _previous) ..begin = begin ..modeToken = modeToken ..transaction = transaction; } CommitStatement _commit() { Token commitOrEnd; if (_match(const [TokenType.commit, TokenType.end])) { commitOrEnd = _previous; } else { _error('Expected COMMIT or END here'); } Token? transaction; if (_matchOne(TokenType.transaction)) { transaction = _previous; } return CommitStatement() ..setSpan(commitOrEnd, _previous) ..commitOrEnd = commitOrEnd ..transaction = transaction; } CrudStatement? _crud() { final withClause = _withClause(); if (_check(TokenType.select) || _check(TokenType.$values)) { return select(withClause: withClause); } else if (_check(TokenType.delete)) { return _deleteStmt(withClause); } else if (_check(TokenType.update)) { return _update(withClause); } else if (_check(TokenType.insert) || _check(TokenType.replace)) { return _insertStmt(withClause); } // A WITH clause without a following select, insert, delete or update // is invalid! if (withClause != null) { _error('Expected a SELECT, INSERT, UPDATE or DELETE statement to ' 'follow this WITH clause.'); } return null; } WithClause? _withClause() { if (!_matchOne(TokenType.$with)) return null; final withToken = _previous; final recursive = _matchOne(TokenType.recursive); final recursiveToken = recursive ? _previous : null; final ctes = []; do { final name = _consumeIdentifier('Expected name for common table'); List? columnNames; // can optionally declare the column names in (foo, bar, baz) syntax if (_matchOne(TokenType.leftParen)) { columnNames = []; do { final identifier = _consumeIdentifier('Expected column name'); columnNames.add(identifier.identifier); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing bracket after column names'); } final asToken = _consume(TokenType.as, 'Expected AS'); MaterializationHint? hint; Token? not, materialized; if (_matchOne(TokenType.not)) { not = _previous; materialized = _consume(TokenType.materialized); hint = MaterializationHint.notMaterialized; } else if (_matchOne(TokenType.materialized)) { materialized = _previous; hint = MaterializationHint.materialized; } const msg = 'Expected select statement in brackets'; _consume(TokenType.leftParen, msg); final selectStmt = select() ?? _error(msg); _consume(TokenType.rightParen, msg); ctes.add(CommonTableExpression( cteTableName: name.identifier, materializationHint: hint, columnNames: columnNames, as: selectStmt, ) ..setSpan(name, _previous) ..asToken = asToken ..tableNameToken = name ..not = not ..materialized = materialized); } while (_matchOne(TokenType.comma)); return WithClause( recursive: recursive, ctes: ctes, ) ..setSpan(withToken, _previous) ..recursiveToken = recursiveToken ..withToken = withToken; } /// Parses a select statement as defined in [the sqlite documentation][s-d], /// which means that compound selects and a with clause is supported. /// /// [s-d]: https://sqlite.org/syntax/select-stmt.html BaseSelectStatement? _fullSelect() { final clause = _withClause(); return select(withClause: clause); } /// Parses a [BaseSelectStatement], which is either a [SelectStatement] or a /// [CompoundSelectStatement]. If [noCompound] is set to true, the parser will /// only attempt to parse a [SelectStatement]. /// /// This method doesn't parse WITH clauses, most users would probably want to /// use [_fullSelect] instead. /// /// See also: /// https://www.sqlite.org/lang_select.html BaseSelectStatement? select({bool? noCompound, WithClause? withClause}) { if (noCompound == true) { return _selectNoCompound(withClause); } else { final firstTokenOfBase = _peek; final first = _selectNoCompound(withClause); if (first == null) { // _selectNoCompound returns null if there's no select statement at the // current position. That's fine if we didn't encounter an with clause // already if (withClause != null) { _error('Expected a SELECT statement to follow the WITH clause here'); } return null; } final parts = []; for (;;) { final part = _compoundSelectPart(); if (part != null) { parts.add(part); } else { break; } } if (parts.isEmpty) { // no compound parts, just return the simple select statement. return first; } else { // remove with clause from base select, it belongs to the compound // select. first.withClause = null; first.first = firstTokenOfBase; return CompoundSelectStatement( withClause: withClause, base: first, additional: parts, )..setSpan(withClause?.first ?? first.first!, _previous); } } } SelectStatementNoCompound? _selectNoCompound([WithClause? withClause]) { if (_peek.type == TokenType.$values) return _valuesSelect(withClause); if (!_match(const [TokenType.select])) return null; final selectToken = _previous; var distinct = false; if (_matchOne(TokenType.distinct)) { distinct = true; } else if (_matchOne(TokenType.all)) { distinct = false; } final resultColumns = _resultColumns(); final from = _from(); final where = _whereOrNull(); final groupBy = _groupBy(); final windowDecls = _windowDeclarations(); final orderBy = _orderBy(); final limit = _limit(); final first = withClause?.first ?? selectToken; return SelectStatement( withClause: withClause, distinct: distinct, columns: resultColumns, from: from, where: where, groupBy: groupBy, windowDeclarations: windowDecls, orderBy: orderBy, limit: limit, )..setSpan(first, _previous); } ValuesSelectStatement? _valuesSelect([WithClause? withClause]) { if (!_matchOne(TokenType.$values)) return null; final firstToken = _previous; final tuples = []; do { tuples.add(_consumeTuple() as Tuple); } while (_matchOne(TokenType.comma)); return ValuesSelectStatement(tuples, withClause: withClause) ..setSpan(firstToken, _previous); } CompoundSelectPart? _compoundSelectPart() { if (_match( const [TokenType.union, TokenType.intersect, TokenType.except])) { final firstModeToken = _previous; var mode = const { TokenType.union: CompoundSelectMode.union, TokenType.intersect: CompoundSelectMode.intersect, TokenType.except: CompoundSelectMode.except, }[firstModeToken.type]; Token? allToken; if (firstModeToken.type == TokenType.union && _matchOne(TokenType.all)) { allToken = _previous; mode = CompoundSelectMode.unionAll; } final select = _selectNoCompound(); if (select == null) { _error('Expected a select statement here!'); } return CompoundSelectPart( mode: mode!, select: select, ) ..firstModeToken = firstModeToken ..allToken = allToken ..setSpan(firstModeToken, _previous); } return null; } /// Returns an identifier followed after an optional "AS" token in sql. /// Returns null if there is IdentifierToken? _as() { if (_match(const [TokenType.as])) { return _consume(TokenType.identifier, 'Expected an identifier') as IdentifierToken; } else if (_match(const [TokenType.identifier])) { return _previous as IdentifierToken; } else { return null; } } Queryable? _from() { if (!_matchOne(TokenType.from)) return null; // Can either be a list of or a join. Joins also start // with a TableOrSubquery, so let's first parse that. final start = _tableOrSubquery(); // parse join, if there is one return _joinClause(start) ?? start; } TableOrSubquery _tableOrSubquery({bool allowAlias = true}) { // this is what we're parsing: https://www.sqlite.org/syntax/table-or-subquery.html // we currently only support regular tables, table functions and nested // selects final tableRef = _tableReferenceOrNull(allowAlias: allowAlias); if (tableRef != null) { // this is a bit hacky. If the table reference only consists of one // identifer and it's followed by a (, it's a table-valued function if (tableRef.as == null && _matchOne(TokenType.leftParen)) { final params = _functionParameters(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); final alias = allowAlias ? _as() : null; return TableValuedFunction(tableRef.tableName, params, as: alias?.identifier) ..setSpan(tableRef.first!, _previous); } return tableRef; } else if (_matchOne(TokenType.leftParen)) { final first = _previous; final innerStmt = _fullSelect()!; _consume(TokenType.rightParen, 'Expected a right bracket to terminate the inner select'); final alias = allowAlias ? _as() : null; return SelectStatementAsSource( statement: innerStmt, as: alias?.identifier) ..setSpan(first, _previous); } _error('Expected a table name or a nested select statement'); } TableReference? _tableReferenceOrNull({bool allowAlias = true}) { _suggestHint(const TableNameDescription()); if (_check(TokenType.identifier)) { return _tableReference(allowAlias: allowAlias); } return null; } JoinClause? _joinClause(TableOrSubquery start) { var operator = _optionalJoinOperator(); if (operator == null) { return null; } final joins = []; while (operator != null) { final first = _peek; final subquery = _tableOrSubquery(); final constraint = _joinConstraint(); joins.add(Join( operator: operator, query: subquery, constraint: constraint, )..setSpan(first, _previous)); // parse the next operator, if there is more than one join operator = _optionalJoinOperator(); } return JoinClause(primary: start, joins: joins) ..setSpan(start.first!, _previous); } /// Parses https://www.sqlite.org/syntax/join-operator.html JoinOperator? _optionalJoinOperator() { if (_matchOne(TokenType.comma) || _matchOne(TokenType.join)) { return JoinOperator(_previous.type == TokenType.comma ? JoinOperatorKind.comma : JoinOperatorKind.none) ..setSpan(_previous, _previous); } const canAppearAfterNatural = { TokenType.left: JoinOperatorKind.left, TokenType.right: JoinOperatorKind.right, TokenType.full: JoinOperatorKind.full, TokenType.inner: JoinOperatorKind.inner, }; final first = _peek; var kind = JoinOperatorKind.none; var natural = false; var outer = false; if (_matchOne(TokenType.natural)) { natural = true; if (_match(canAppearAfterNatural.keys)) { kind = canAppearAfterNatural[_previous.type]!; } } else if (_match(canAppearAfterNatural.keys)) { kind = canAppearAfterNatural[_previous.type]!; } else if (_matchOne(TokenType.cross)) { kind = JoinOperatorKind.cross; } else { return null; } if (kind.supportsOuterKeyword && _matchOne(TokenType.outer)) { outer = true; } _consume(TokenType.join); return JoinOperator(kind, natural: natural, outer: outer) ..setSpan(first, _previous); } /// Parses https://www.sqlite.org/syntax/join-constraint.html JoinConstraint? _joinConstraint() { if (_matchOne(TokenType.on)) { return OnConstraint(expression: expression()); } else if (_matchOne(TokenType.using)) { _consume(TokenType.leftParen, 'Expected an opening paranthesis'); final columnNames = []; do { final identifier = _consume(TokenType.identifier, 'Expected a column name'); columnNames.add((identifier as IdentifierToken).identifier); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected an closing paranthesis'); return UsingConstraint(columnNames: columnNames); } else { return null; } } /// Parses a where clause if there is one at the current position Expression? _whereOrNull() { if (_matchOne(TokenType.where)) { return expression(); } return null; } GroupBy? _groupBy() { if (_matchOne(TokenType.group)) { final groupToken = _previous; _consume(TokenType.by, 'Expected a "BY"'); final by = []; Expression? having; do { by.add(expression()); } while (_matchOne(TokenType.comma)); if (_matchOne(TokenType.having)) { having = expression(); } return GroupBy(by: by, having: having)..setSpan(groupToken, _previous); } return null; } List _windowDeclarations() { final declarations = []; if (_matchOne(TokenType.window)) { do { final name = _consumeIdentifier('Expected a name for the window'); _consume(TokenType.as, 'Expected AS between the window name and its definition'); final window = _windowDefinition(); declarations.add(NamedWindowDeclaration(name.identifier, window)); } while (_matchOne(TokenType.comma)); } return declarations; } OrderByBase? _orderBy() { if (_matchOne(TokenType.order)) { final orderToken = _previous; _consume(TokenType.by, 'Expected "BY" after "ORDER" token'); final terms = []; do { terms.add(_orderingTerm()); } while (_matchOne(TokenType.comma)); // If we only hit a single ordering term and that term is a Dart // placeholder, we can upgrade that term to a full order by placeholder. // This gives users more control at runtime (they can specify multiple // terms). if (terms.length == 1 && terms.single is DartOrderingTermPlaceholder) { final termPlaceholder = terms.single as DartOrderingTermPlaceholder; return DartOrderByPlaceholder(name: termPlaceholder.name) ..setSpan(orderToken, termPlaceholder.last!); } return OrderBy(terms: terms)..setSpan(orderToken, _previous); } return null; } OrderingTermBase _orderingTerm() { final expr = expression(); final mode = _orderingModeOrNull(); OrderingBehaviorForNulls? nulls; if (_matchOne(TokenType.nulls)) { if (_matchOne(TokenType.first)) { nulls = OrderingBehaviorForNulls.first; } else if (_matchOne(TokenType.last)) { nulls = OrderingBehaviorForNulls.last; } else { _error('Expected FIRST or LAST here'); } } // if there is nothing (asc/desc, nulls first/last) after a Dart // placeholder, we can upgrade the expression to an ordering term // placeholder and let users define the mode at runtime. if (mode == null && nulls == null && expr is DartExpressionPlaceholder) { return DartOrderingTermPlaceholder(name: expr.name) ..setSpan(expr.first!, expr.last!); } return OrderingTerm(expression: expr, orderingMode: mode, nulls: nulls) ..setSpan(expr.first!, _previous); } OrderingMode? _orderingModeOrNull() { if (_match(const [TokenType.asc, TokenType.desc])) { final mode = _previous.type == TokenType.asc ? OrderingMode.ascending : OrderingMode.descending; return mode; } return null; } /// Parses a [Limit] clause, or returns null if there is no limit token after /// the current position. LimitBase? _limit() { if (!_matchOne(TokenType.limit)) return null; final limitToken = _previous; // Unintuitive, it's "$amount OFFSET $offset", but "$offset, $amount" // the order changes between the separator tokens. final first = expression(); if (_matchOne(TokenType.comma)) { final separator = _previous; final count = expression(); return Limit(count: count, offsetSeparator: separator, offset: first) ..setSpan(limitToken, _previous); } else if (_matchOne(TokenType.offset)) { final separator = _previous; final offset = expression(); return Limit(count: first, offsetSeparator: separator, offset: offset) ..setSpan(limitToken, _previous); } else { // no offset or comma was parsed (so just LIMIT $expr). In that case, we // want to provide additional flexibility to the user by interpreting the // expression as a whole limit clause. if (first is DartExpressionPlaceholder) { return DartLimitPlaceholder(name: first.name) ..setSpan(limitToken, _previous); } return Limit(count: first)..setSpan(limitToken, _previous); } } DeleteStatement? _deleteStmt([WithClause? withClause]) { if (!_matchOne(TokenType.delete)) return null; final deleteToken = _previous; _consume(TokenType.from, 'Expected a FROM here'); final table = _tableReference(); final where = _whereOrNull(); final returning = _returningOrNull(); return DeleteStatement( withClause: withClause, from: table, where: where, returning: returning, )..setSpan(withClause?.first ?? deleteToken, _previous); } UpdateStatement? _update([WithClause? withClause]) { if (!_matchOne(TokenType.update)) return null; final updateToken = _previous; FailureMode? failureMode; if (_matchOne(TokenType.or)) { failureMode = UpdateStatement.failureModeFromToken(_advance().type); } final table = _tableReference(); _consume(TokenType.set, 'Expected SET after the table name'); final set = _setComponents(); final from = _from(); final where = _whereOrNull(); final returning = _returningOrNull(); return UpdateStatement( withClause: withClause, or: failureMode, table: table, set: set, from: from, where: where, returning: returning, )..setSpan(withClause?.first ?? updateToken, _previous); } SingleColumnSetComponent _singleColumnSetComponent() { final columnName = _consumeIdentifier('Expected a column name to set'); final reference = Reference(columnName: columnName.identifier) ..setSpan(columnName, columnName); _consume(TokenType.equal, 'Expected = after the column name'); final expr = expression(); return SingleColumnSetComponent(column: reference, expression: expr) ..setSpan(columnName, _previous); } MultiColumnSetComponent _multiColumnSetComponent() { final first = _consume( TokenType.leftParen, 'Expected opening parenthesis before column list'); final targetColumns = []; do { final columnName = _consumeIdentifier('Expected a column'); targetColumns.add(Reference(columnName: columnName.identifier) ..setSpan(columnName, columnName)); } while (_matchOne(TokenType.comma)); _consume( TokenType.rightParen, 'Expected closing parenthesis after column list'); _consume(TokenType.equal, 'Expected = after the column name list'); final tupleOrSubQuery = _consumeTuple(orSubQuery: true, usedAsRowValue: true); return MultiColumnSetComponent( columns: targetColumns, rowValue: tupleOrSubQuery) ..setSpan(first, _previous); } List _setComponents() { final set = []; do { if (_check(TokenType.leftParen)) { set.add(_multiColumnSetComponent()); } else { set.add(_singleColumnSetComponent()); } } while (_matchOne(TokenType.comma)); return set; } InsertStatement? _insertStmt([WithClause? withClause]) { if (!_match(const [TokenType.insert, TokenType.replace])) return null; final firstToken = _previous; InsertMode? insertMode; if (_previous.type == TokenType.insert) { // insert modes can have a failure clause (INSERT OR xxx) if (_matchOne(TokenType.or)) { const tokensToModes = { TokenType.replace: InsertMode.insertOrReplace, TokenType.rollback: InsertMode.insertOrRollback, TokenType.abort: InsertMode.insertOrAbort, TokenType.fail: InsertMode.insertOrFail, TokenType.ignore: InsertMode.insertOrIgnore }; if (_match(tokensToModes.keys)) { insertMode = tokensToModes[_previous.type]; } else { _error('After the INSERT OR, expected an insert mode ' '(REPLACE, ROLLBACK, etc.)'); } } else { insertMode = InsertMode.insert; } } else { // if it wasn't an insert, it must have been a replace insertMode = InsertMode.replace; } assert(insertMode != null); _consume(TokenType.into, 'Expected INSERT INTO'); final table = _tableReference(); final targetColumns = []; if (_matchOne(TokenType.leftParen)) { do { final columnRef = _consumeIdentifier('Expected a column'); targetColumns.add(Reference(columnName: columnRef.identifier) ..setSpan(columnRef, columnRef)); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing parenthesis after column list'); } final source = _insertSource(); final upsert = []; while (_check(TokenType.on)) { upsert.add(_upsertClauseEntry()); } final returning = _returningOrNull(); return InsertStatement( withClause: withClause, mode: insertMode!, table: table, targetColumns: targetColumns, source: source, upsert: upsert.isEmpty ? null : (UpsertClause(upsert) ..setSpan(upsert.first.first!, upsert.last.last!)), returning: returning, )..setSpan(withClause?.first ?? firstToken, _previous); } InsertSource _insertSource() { if (_matchOne(TokenType.$values)) { final first = _previous; final values = []; do { // it will be a tuple, we don't turn on "orSubQuery" values.add(_consumeTuple() as Tuple); } while (_matchOne(TokenType.comma)); return ValuesSource(values)..setSpan(first, _previous); } else if (_matchOne(TokenType.$default)) { final first = _previous; _consume(TokenType.$values, 'Expected DEFAULT VALUES'); return DefaultValues()..setSpan(first, _previous); } else if (enableDriftExtensions && _matchOne(TokenType.dollarSignVariable)) { final token = _previous as DollarSignVariableToken; return DartInsertablePlaceholder(name: token.name) ..token = token ..setSpan(token, token); } else { final first = _previous; return SelectInsertSource( _fullSelect() ?? _error('Expeced a select statement'), )..setSpan(first, _previous); } } UpsertClauseEntry _upsertClauseEntry() { final first = _consume(TokenType.on); _consume(TokenType.conflict, 'Expected CONFLICT keyword for upsert clause'); List? indexedColumns; Expression? where; if (_matchOne(TokenType.leftParen)) { indexedColumns = _indexedColumns(); _consume(TokenType.rightParen, 'Expected closing paren here'); if (_matchOne(TokenType.where)) { where = expression(); } } _consume(TokenType.$do, 'Expected DO, followed by the action (NOTHING or UPDATE SET)'); late UpsertAction action; if (_matchOne(TokenType.nothing)) { action = DoNothing()..setSpan(_previous, _previous); } else if (_check(TokenType.update)) { action = _doUpdate(); } return UpsertClauseEntry( onColumns: indexedColumns, where: where, action: action, )..setSpan(first, _previous); } DoUpdate _doUpdate() { _consume(TokenType.update, 'Expected UPDATE SET keyword here'); final first = _previous; _consume(TokenType.set, 'Expected UPDATE SET keyword here'); final set = _setComponents(); Expression? where; if (_matchOne(TokenType.where)) { where = expression(); } return DoUpdate(set, where: where)..setSpan(first, _previous); } /// https://www.sqlite.org/syntax/window-defn.html WindowDefinition _windowDefinition() { _consume(TokenType.leftParen, 'Expected opening parenthesis'); final leftParen = _previous; String? baseWindowName; OrderByBase? orderBy; final partitionBy = []; if (_matchOne(TokenType.identifier)) { baseWindowName = (_previous as IdentifierToken).identifier; } if (_matchOne(TokenType.partition)) { _consume(TokenType.by, 'Expected PARTITION BY'); do { partitionBy.add(expression()); } while (_matchOne(TokenType.comma)); } if (_peek.type == TokenType.order) { orderBy = _orderBy(); } final spec = _frameSpec(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); return WindowDefinition( baseWindowName: baseWindowName, partitionBy: partitionBy, orderBy: orderBy, frameSpec: spec ?? (FrameSpec()..synthetic = true), )..setSpan(leftParen, _previous); } /// https://www.sqlite.org/syntax/frame-spec.html FrameSpec? _frameSpec() { if (!_match(const [TokenType.range, TokenType.rows, TokenType.groups])) { return null; } final typeToken = _previous; final frameType = const { TokenType.range: FrameType.range, TokenType.rows: FrameType.rows, TokenType.groups: FrameType.groups }[typeToken.type]; FrameBoundary start, end; // if there is no between token, we just read the start boundary and set the // end to currentRow. See the link in the docs if (_matchOne(TokenType.between)) { start = _frameBoundary(isStartBounds: true, parseExprFollowing: true); _consume(TokenType.and, 'Expected AND followed by the ending boundary'); end = _frameBoundary(isStartBounds: false, parseExprFollowing: true); } else { // FOLLOWING is not supported in the short-hand syntax start = _frameBoundary(isStartBounds: true, parseExprFollowing: false); end = FrameBoundary.currentRow(); } var exclude = ExcludeMode.noOthers; if (_matchOne(TokenType.exclude)) { if (_matchOne(TokenType.ties)) { exclude = ExcludeMode.ties; } else if (_matchOne(TokenType.group)) { exclude = ExcludeMode.group; } else if (_matchOne(TokenType.current)) { _consume(TokenType.row, 'Expected EXCLUDE CURRENT ROW'); exclude = ExcludeMode.currentRow; } else if (_matchOne(TokenType.no)) { _consume(TokenType.others, 'Expected EXCLUDE NO OTHERS'); exclude = ExcludeMode.noOthers; } } return FrameSpec( type: frameType, excludeMode: exclude, start: start, end: end, )..setSpan(typeToken, _previous); } FrameBoundary _frameBoundary( {bool isStartBounds = true, bool parseExprFollowing = true}) { // the CURRENT ROW boundary is supported for all modes if (_matchOne(TokenType.current)) { _consume(TokenType.row, 'Expected ROW to finish CURRENT ROW boundary'); return FrameBoundary.currentRow(); } if (_matchOne(TokenType.unbounded)) { // if this is a start boundary, only UNBOUNDED PRECEDING makes sense. // Otherwise, only UNBOUNDED FOLLOWING makes sense if (isStartBounds) { _consume(TokenType.preceding, 'Expected UNBOUNDED PRECEDING'); return FrameBoundary.unboundedPreceding(); } else { _consume(TokenType.following, 'Expected UNBOUNDED FOLLOWING'); return FrameBoundary.unboundedFollowing(); } } // ok, not unbounded or CURRENT ROW. It must be PRECEDING|FOLLOWING // then final amount = expression(); if (parseExprFollowing && _matchOne(TokenType.following)) { return FrameBoundary.following(amount); } else if (_matchOne(TokenType.preceding)) { return FrameBoundary.preceding(amount); } _error('Expected either PRECEDING or FOLLOWING here'); } Returning? _returningOrNull() { if (!_matchOne(TokenType.returning)) return null; final previous = _previous; return Returning(_resultColumns())..setSpan(previous, _previous); } List _resultColumns() { final columns = []; do { columns.add(_resultColumn()); } while (_matchOne(TokenType.comma)); return columns; } /// Parses a [ResultColumn] or throws if none is found. /// https://www.sqlite.org/syntax/result-column.html ResultColumn _resultColumn() { if (_matchOne(TokenType.star)) { return StarResultColumn(null)..setSpan(_previous, _previous); } final positionBefore = _current; if (_matchOne(TokenType.identifier)) { // two options. the identifier could be followed by ".*", in which case // we have a star result column. If it's followed by anything else, it can // still refer to a column in a table as part of a expression // result column final identifier = _previous as IdentifierToken; if (_matchOne(TokenType.dot)) { if (_matchOne(TokenType.star)) { return StarResultColumn(identifier.identifier) ..setSpan(identifier, _previous); } else if (enableDriftExtensions && _matchOne(TokenType.doubleStar)) { final as = _as(); return NestedStarResultColumn( tableName: identifier.identifier, as: as?.identifier, )..setSpan(identifier, _previous); } } // not a star result column. go back and parse the expression. // todo this is a bit unorthodox. is there a better way to parse the // expression from before? _current = positionBefore; } // parsing for the nested query column if (enableDriftExtensions && _matchOne(TokenType.list)) { final list = _previous; _consume( TokenType.leftParen, 'Expected opening parenthesis after LIST', ); final statement = _fullSelect(); if (statement == null || statement is! SelectStatement) { _error('Expected a select statement here'); } _consume( TokenType.rightParen, 'Expected closing parenthesis to finish LIST expression', ); final as = _as(); return NestedQueryColumn(select: statement, as: as?.identifier) ..setSpan(list, _previous); } final tokenBefore = _peek; final expr = expression(); MappedBy? mappedBy; if (enableDriftExtensions && _matchOne(TokenType.mapped)) { final mapped = _previous; _consume(TokenType.by, 'Expected `BY` to follow `MAPPED` here'); final dart = _consume( TokenType.inlineDart, 'Expected Dart converter in backticks'); mappedBy = MappedBy(null, dart as InlineDartToken)..setSpan(mapped, dart); } final as = _as(); return ExpressionResultColumn( expression: expr, mappedBy: mappedBy, as: as?.identifier, )..setSpan(tokenBefore, _previous); } SchemaStatement? _create() { if (!_matchOne(TokenType.create)) return null; if (_check(TokenType.table) || _check(TokenType.virtual)) { return _createTable(); } else if (_check(TokenType.trigger)) { return _createTrigger(); } else if (_check(TokenType.unique) || _check(TokenType.$index)) { return _createIndex(); } else if (_check(TokenType.view)) { return _createView(); } _error( 'Expected a TABLE, TRIGGER, INDEX or VIEW to be defined after the CREATE keyword.'); } /// Parses a `CREATE TABLE` statement, assuming that the `CREATE` token has /// already been matched. TableInducingStatement _createTable() { final first = _previous; assert(first.type == TokenType.create); final virtual = _matchOne(TokenType.virtual); _consume(TokenType.table, 'Expected TABLE keyword here'); final ifNotExists = _ifNotExists(); final tableIdentifier = _consumeIdentifier('Expected a table name'); if (virtual) { return _virtualTable(first, ifNotExists, tableIdentifier); } // we don't currently support CREATE TABLE x AS SELECT ... statements final leftParen = _consume( TokenType.leftParen, 'Expected opening parenthesis to list columns'); final columns = []; final tableConstraints = []; // the columns must come before the table constraints! var encounteredTableConstraint = false; _withErrorRecovery(InParentheses(leftParen, leftParen.match), () { do { _withErrorRecovery(InCommaSeparatedList(), () { final tableConstraint = tableConstraintOrNull(); if (tableConstraint != null) { encounteredTableConstraint = true; tableConstraints.add(tableConstraint); } else { if (encounteredTableConstraint) { _error('Expected another table constraint'); } else { columns.add(_columnDefinition()); } } if (!_checkAny([TokenType.comma, TokenType.rightParen])) { _error('Unrecognized table or column constraint, expected comma or ' 'closing parenthesis here.'); } }); } while (_matchOne(TokenType.comma)); }); final rightParen = _consume(TokenType.rightParen, 'Expected closing parenthesis'); var withoutRowId = false; var isStrict = false; Token? strict; // Parses a `WITHOUT ROWID` or a `STRICT` keyword. Returns if either such // option has been parsed. bool tableOptions() { if (_matchOne(TokenType.strict)) { isStrict = true; strict = _previous; return true; } else if (_matchOne(TokenType.without)) { _consume(TokenType.rowid, 'Expected ROWID to complete the WITHOUT ROWID part'); withoutRowId = true; return true; } return false; } // Table options can be seperated by comma, but they're not required either. if (tableOptions()) { while (_matchOne(TokenType.comma)) { if (!tableOptions()) { _error('Expected WITHOUT ROWID or STRICT here!'); } } } final overriddenName = _driftTableName(); return CreateTableStatement( ifNotExists: ifNotExists, tableName: tableIdentifier.identifier, withoutRowId: withoutRowId, columns: columns, tableConstraints: tableConstraints, isStrict: isStrict, driftTableName: overriddenName, ) ..setSpan(first, _previous) ..openingBracket = leftParen ..tableNameToken = tableIdentifier ..closingBracket = rightParen ..strict = strict; } /// Parses a `CREATE VIRTUAL TABLE` statement, after the `CREATE VIRTUAL TABLE /// ` tokens have already been read. CreateVirtualTableStatement _virtualTable( Token first, bool ifNotExists, IdentifierToken nameToken) { _consume(TokenType.using, 'Expected USING for virtual table declaration'); final moduleName = _consumeIdentifier('Expected a module name'); final args = []; if (_matchOne(TokenType.leftParen)) { // args can be just about anything, so we accept any token until the right // parenthesis closing it of. Token? currentStart; var levelOfParens = 0; void addCurrent() { if (currentStart == null) { _error('Expected at least one token for the previous argument'); } else { args.add(currentStart!.span.expand(_previous.span)); currentStart = null; } } for (;;) { // begin reading a single argument, which is stopped by a comma or // maybe with a ), if the current depth is one while (_peek.type != TokenType.rightParen && _peek.type != TokenType.comma) { _advance(); if (_previous.type == TokenType.leftParen) { levelOfParens++; } currentStart ??= _previous; } // if we just read the last ) of the argument list, finish. Otherwise // just handle the ) and continue reading the same argument if (_peek.type == TokenType.rightParen) { levelOfParens--; if (levelOfParens < 0) { addCurrent(); _advance(); // consume the rightParen break; } else { _advance(); // add the rightParen to the current argument continue; } } // finished while loop above, but not with a ), so it must be a comma // that finishes the current argument assert(_peek.type == TokenType.comma); addCurrent(); _advance(); // consume the comma } } final driftTableName = _driftTableName(); return CreateVirtualTableStatement( ifNotExists: ifNotExists, tableName: nameToken.identifier, moduleName: moduleName.identifier, arguments: args, driftTableName: driftTableName, ) ..setSpan(first, _previous) ..tableNameToken = nameToken ..moduleNameToken = moduleName; } DriftTableName? _driftTableName({bool supportAs = true}) { final types = supportAs ? const [TokenType.as, TokenType.$with] : [TokenType.$with]; if (enableDriftExtensions && (_match(types))) { return _startedDriftTableName(_previous); } return null; } DriftTableName _startedDriftTableName(Token first) { final useExisting = _previous.type == TokenType.$with; final name = _consumeIdentifier('Expected the name for the data class').identifier; String? constructorName; if (_matchOne(TokenType.dot)) { constructorName = _consumeIdentifier( 'Expected name of the constructor to use after the dot') .identifier; } return DriftTableName( useExistingDartClass: useExisting, overriddenDataClassName: name, constructorName: constructorName, )..setSpan(first, _previous); } /// Parses a "CREATE TRIGGER" statement, assuming that the create token has /// already been consumed. CreateTriggerStatement? _createTrigger() { final create = _previous; assert(create.type == TokenType.create); if (!_matchOne(TokenType.trigger)) return null; final ifNotExists = _ifNotExists(); final trigger = _consumeIdentifier('Expected a name for the identifier'); TriggerMode mode; if (_matchOne(TokenType.before)) { mode = TriggerMode.before; } else if (_matchOne(TokenType.after)) { mode = TriggerMode.after; } else { const msg = 'Expected BEFORE, AFTER or INSTEAD OF'; _consume(TokenType.instead, msg); _consume(TokenType.of, msg); mode = TriggerMode.insteadOf; } TriggerTarget target; if (_matchOne(TokenType.delete)) { target = DeleteTarget() ..deleteToken = _previous ..setSpan(_previous, _previous); } else if (_matchOne(TokenType.insert)) { target = InsertTarget() ..insertToken = _previous ..setSpan(_previous, _previous); } else { final updateToken = _consume( TokenType.update, 'Expected DELETE, INSERT or UPDATE as a trigger'); final names = []; if (_matchOne(TokenType.of)) { do { final name = _consumeIdentifier('Expected column name in ON clause'); final reference = Reference(columnName: name.identifier) ..setSpan(name, name); names.add(reference); } while (_matchOne(TokenType.comma)); } target = UpdateTarget(names) ..updateToken = updateToken ..setSpan(updateToken, _previous); } _consume(TokenType.on, 'Expected ON'); _suggestHint(const TableNameDescription()); final nameToken = _consumeIdentifier('Expected a table name'); final tableRef = TableReference(nameToken.identifier) ..setSpan(nameToken, nameToken); if (_matchOne(TokenType.$for)) { const msg = 'Expected FOR EACH ROW'; _consume(TokenType.each, msg); _consume(TokenType.row, msg); } Expression? when; if (_matchOne(TokenType.when)) { when = expression(); } final block = _consumeBlock(); return CreateTriggerStatement( ifNotExists: ifNotExists, triggerName: trigger.identifier, mode: mode, target: target, onTable: tableRef, when: when, action: block, ) ..setSpan(create, _previous) ..triggerNameToken = trigger; } /// Parses a [CreateViewStatement]. The `CREATE` token must have already been /// accepted. CreateViewStatement? _createView() { final create = _previous; assert(create.type == TokenType.create); if (!_matchOne(TokenType.view)) return null; final ifNotExists = _ifNotExists(); final name = _consumeIdentifier('Expected a name for this view'); DriftTableName? driftTableName; var skippedToSelect = false; if (enableDriftExtensions) { if (_check(TokenType.$with)) { driftTableName = _driftTableName(); } else if (_matchOne(TokenType.as)) { // This can either be a data class name or the beginning of the select if (_check(TokenType.identifier)) { // It's a data class name driftTableName = _startedDriftTableName(_previous); } else { // No, we'll expect the SELECT next. skippedToSelect = true; } } } List? columnNames; if (!skippedToSelect) { if (_matchOne(TokenType.leftParen)) { columnNames = _columnNames(); _consume(TokenType.rightParen, 'Expected closing bracket'); } _consume(TokenType.as, 'Expected AS SELECT'); } final query = _fullSelect(); if (query == null) { _error('Expected a SELECT statement here'); } return CreateViewStatement( ifNotExists: ifNotExists, viewName: name.identifier, columns: columnNames, query: query, driftTableName: driftTableName, ) ..viewNameToken = name ..setSpan(create, _previous); } /// Parses a [CreateIndexStatement]. The `CREATE` token must have already been /// accepted. CreateIndexStatement? _createIndex() { final create = _previous; assert(create.type == TokenType.create); final unique = _matchOne(TokenType.unique); if (!_matchOne(TokenType.$index)) return null; final ifNotExists = _ifNotExists(); final name = _consumeIdentifier('Expected a name for this index'); _consume(TokenType.on, 'Expected ON table'); _suggestHint(const TableNameDescription()); final nameToken = _consumeIdentifier('Expected a table name'); final tableRef = TableReference(nameToken.identifier) ..setSpan(nameToken, nameToken); _consume(TokenType.leftParen, 'Expected indexed columns in parentheses'); final indexes = _indexedColumns(); _consume(TokenType.rightParen, 'Expected closing bracket'); Expression? where; if (_matchOne(TokenType.where)) { where = expression(); } return CreateIndexStatement( indexName: name.identifier, unique: unique, ifNotExists: ifNotExists, on: tableRef, columns: indexes, where: where, ) ..nameToken = name ..setSpan(create, _previous); } List _columnNames() { final columns = []; do { final colName = _consumeIdentifier('Expected a name for this column'); columns.add(colName.identifier); } while (_matchOne(TokenType.comma)); return columns; } List _indexedColumns() { final indexes = []; do { final expr = expression(); final mode = _orderingModeOrNull(); indexes.add(IndexedColumn(expr, mode)..setSpan(expr.first!, _previous)); } while (_matchOne(TokenType.comma)); return indexes; } /// Parses `IF NOT EXISTS` | epsilon bool _ifNotExists() { if (_matchOne(TokenType.$if)) { _consume(TokenType.not, 'Expected IF to be followed by NOT EXISTS'); _consume(TokenType.exists, 'Expected IF NOT to be followed by EXISTS'); return true; } return false; } ColumnDefinition _columnDefinition() { final name = _consumeIdentifier('Expected a column name'); final typeTokens = _typeName(); String? typeName; if (typeTokens != null) { typeName = typeTokens.lexeme; } final constraints = []; ColumnConstraint? constraint; while ((constraint = _columnConstraint(orNull: true)) != null) { constraints.add(constraint!); } return ColumnDefinition( columnName: name.identifier, typeName: typeName, constraints: constraints, ) ..setSpan(name, _previous) ..typeNames = typeTokens ..nameToken = name; } List? _typeName() { if (enableDriftExtensions && _matchOne(TokenType.inlineDart)) { return [_previous]; } // sqlite doesn't really define what a type name is and has very loose rules // at turning them into a type affinity. We support this pattern: // typename = identifier [ "(" { identifier | comma | number_literal } ")" ] if (!_matchOne(TokenType.identifier)) return null; final typeNames = [_previous]; if (_matchOne(TokenType.leftParen)) { typeNames.add(_previous); const inBrackets = [ TokenType.identifier, TokenType.comma, TokenType.numberLiteral ]; while (_match(inBrackets)) { typeNames.add(_previous); } _consume(TokenType.rightParen, 'Expected closing parenthesis to finish type name'); typeNames.add(_previous); } return typeNames; } ColumnConstraint? _columnConstraint({bool orNull = false}) { final first = _peek; final resolvedName = _constraintNameOrNull()?.identifier; if (_matchOne(TokenType.primary)) { _suggestHint(HintDescription.token(TokenType.key)); _consume(TokenType.key, 'Expected KEY to complete PRIMARY KEY clause'); final mode = _orderingModeOrNull(); final conflict = _conflictClauseOrNull(); _suggestHint(HintDescription.token(TokenType.autoincrement)); final hasAutoInc = _matchOne(TokenType.autoincrement); return PrimaryKeyColumn(resolvedName, autoIncrement: hasAutoInc, mode: mode, onConflict: conflict) ..setSpan(first, _previous); } if (_matchOne(TokenType.$null)) { final nullToken = _previous; return NullColumnConstraint(resolvedName, $null: nullToken) ..setSpan(nullToken, nullToken); } if (_matchOne(TokenType.not)) { _suggestHint(HintDescription.token(TokenType.$null)); final notToken = _previous; final nullToken = _consume(TokenType.$null, 'Expected NULL to complete NOT NULL'); return NotNull(resolvedName, onConflict: _conflictClauseOrNull()) ..setSpan(first, _previous) ..not = notToken ..$null = nullToken; } if (_matchOne(TokenType.unique)) { return UniqueColumn(resolvedName, _conflictClauseOrNull()) ..setSpan(first, _previous); } if (_matchOne(TokenType.check)) { final expr = _expressionInParentheses(); return CheckColumn(resolvedName, expr)..setSpan(first, _previous); } if (_matchOne(TokenType.$default)) { Expression expr; if (_match(const [TokenType.plus, TokenType.minus])) { // Signed number final operator = _previous; expr = UnaryExpression(operator, _numericLiteral()) ..setSpan(operator, _previous); } else { // Literal or an expression in parentheses expr = _literalOrNull() ?? _expressionInParentheses(); } return Default(resolvedName, expr)..setSpan(first, _previous); } if (_matchOne(TokenType.collate)) { final collation = _consumeIdentifier('Expected the collation name'); return CollateConstraint(resolvedName, collation.identifier) ..setSpan(first, _previous); } if (_matchOne(TokenType.generated)) { _consume(TokenType.always); _consume(TokenType.as); _consume(TokenType.leftParen); final expr = expression(); _consume(TokenType.rightParen); bool isStored; if (_matchOne(TokenType.stored)) { isStored = true; } else if (_matchOne(TokenType.virtual)) { isStored = false; } else { isStored = false; } return GeneratedAs(expr, name: resolvedName, stored: isStored) ..setSpan(first, _previous); } if (_peek.type == TokenType.references) { final clause = _foreignKeyClause(); return ForeignKeyColumnConstraint(resolvedName, clause) ..setSpan(first, _previous); } if (enableDriftExtensions && _matchOne(TokenType.mapped)) { _consume(TokenType.by, 'Expected a MAPPED BY constraint'); final dartExpr = _consume( TokenType.inlineDart, 'Expected Dart expression in backticks'); return MappedBy(resolvedName, dartExpr as InlineDartToken) ..setSpan(first, _previous); } if (enableDriftExtensions && _matchOne(TokenType.json)) { final jsonToken = _previous; final keyToken = _consume(TokenType.key, 'Expected a JSON KEY constraint'); final name = _consumeIdentifier('Expected a name for for the json key'); return JsonKey(resolvedName, name) ..setSpan(first, _previous) ..json = jsonToken ..key = keyToken; } if (enableDriftExtensions && _matchOne(TokenType.as)) { final asToken = _previous; final nameToken = _consumeIdentifier('Expected Dart getter name'); return DriftDartName(resolvedName, nameToken) ..setSpan(first, _previous) ..as = asToken; } // no known column constraint matched. If orNull is set and we're not // guaranteed to be in a constraint clause (started with CONSTRAINT), we // can return null if (orNull && resolvedName == null) { return null; } _error('Expected a constraint (primary key, nullability, etc.)'); } TableConstraint? tableConstraintOrNull({bool requireConstraint = false}) { final first = _peek; final nameToken = _constraintNameOrNull(); final name = nameToken?.identifier; TableConstraint? result; if (_match([TokenType.unique, TokenType.primary])) { final isPrimaryKey = _previous.type == TokenType.primary; if (isPrimaryKey) { _consume(TokenType.key, 'Expected KEY to start PRIMARY KEY clause'); } _consume(TokenType.leftParen, 'Expected a left parenthesis to start key columns'); final columns = _indexedColumns(); _consume( TokenType.rightParen, 'Expected a closing parenthesis after columns'); final conflictClause = _conflictClauseOrNull(); result = KeyClause(name, isPrimaryKey: isPrimaryKey, columns: columns, onConflict: conflictClause); } else if (_matchOne(TokenType.check)) { final expr = _expressionInParentheses(); result = CheckTable(name, expr); } else if (_matchOne(TokenType.foreign)) { _consume(TokenType.key, 'Expected KEY to start FOREIGN KEY clause'); final columns = _listColumnsInParentheses(allowEmpty: false); final clause = _foreignKeyClause(); result = ForeignKeyTableConstraint(name, columns: columns, clause: clause); } if (result != null) { result ..setSpan(first, _previous) ..nameToken = nameToken; return result; } if (name != null || requireConstraint) { // if a constraint was started with CONSTRAINT but then we didn't // find a constraint, that's an syntax error _error('Expected a table constraint (e.g. a primary key)'); } return null; } IdentifierToken? _constraintNameOrNull() { if (_matchOne(TokenType.constraint)) { final name = _consumeIdentifier('Expect a name for the constraint here'); return name; } return null; } Expression _expressionInParentheses() { _consume(TokenType.leftParen, 'Expected opening parenthesis'); final expr = expression(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); return expr; } ConflictClause? _conflictClauseOrNull() { _suggestHint(HintDescription.token(TokenType.on)); if (_matchOne(TokenType.on)) { _consume(TokenType.conflict, 'Expected CONFLICT to complete ON CONFLICT clause'); const modes = { TokenType.rollback: ConflictClause.rollback, TokenType.abort: ConflictClause.abort, TokenType.fail: ConflictClause.fail, TokenType.ignore: ConflictClause.ignore, TokenType.replace: ConflictClause.replace, }; _suggestHint(HintDescription.tokens(modes.keys.toList())); if (_match(modes.keys)) { return modes[_previous.type]; } else { _error('Expected a conflict handler (rollback, abort, etc.) here'); } } return null; } TableReference _tableReference({bool allowAlias = true}) { _suggestHint(const TableNameDescription()); final first = _consumeIdentifier('Expected table or schema name here'); IdentifierToken? second; IdentifierToken? as; if (_matchOne(TokenType.dot)) { second = _consumeIdentifier('Expected a table name here'); } if (allowAlias) { as = _as(); } final tableNameToken = second ?? first; return TableReference( tableNameToken.identifier, as: as?.identifier, schemaName: second == null ? null : first.identifier, ) ..setSpan(first, _previous) ..tableNameToken = tableNameToken; } ForeignKeyClause _foreignKeyClause() { // https://www.sqlite.org/syntax/foreign-key-clause.html _consume(TokenType.references, 'Expected REFERENCES'); final firstToken = _previous; final foreignTable = _tableReference(allowAlias: false); final columnNames = _listColumnsInParentheses(allowEmpty: true); ReferenceAction? onDelete, onUpdate; _suggestHint(HintDescription.token(TokenType.on)); while (_matchOne(TokenType.on)) { _suggestHint( const HintDescription.tokens([TokenType.delete, TokenType.update])); if (_matchOne(TokenType.delete)) { onDelete = _referenceAction(); } else if (_matchOne(TokenType.update)) { onUpdate = _referenceAction(); } else { _error('Expected either DELETE or UPDATE'); } } DeferrableClause? deferrable; if (_checkWithNot(TokenType.deferrable)) { final not = _matchOneAndGet(TokenType.not); final deferrableToken = _consume(TokenType.deferrable); InitialDeferrableMode? mode; if (_matchOne(TokenType.initially)) { if (_matchOne(TokenType.deferred)) { mode = InitialDeferrableMode.deferred; } else if (_matchOne(TokenType.immediate)) { mode = InitialDeferrableMode.immediate; } else { _error('Expected DEFERRED or IMMEDIATE here'); } } deferrable = DeferrableClause(not != null, mode) ..setSpan(not ?? deferrableToken, _previous); } return ForeignKeyClause( foreignTable: foreignTable, columnNames: columnNames, onUpdate: onUpdate, onDelete: onDelete, deferrable: deferrable, )..setSpan(firstToken, _previous); } ReferenceAction _referenceAction() { if (_matchOne(TokenType.cascade)) { return ReferenceAction.cascade; } else if (_matchOne(TokenType.restrict)) { return ReferenceAction.restrict; } else if (_matchOne(TokenType.no)) { _consume(TokenType.action, 'Expect ACTION to complete NO ACTION clause'); return ReferenceAction.noAction; } else if (_matchOne(TokenType.set)) { if (_matchOne(TokenType.$null)) { return ReferenceAction.setNull; } else if (_matchOne(TokenType.$default)) { return ReferenceAction.setDefault; } else { _error('Expected either NULL or DEFAULT as set action here'); } } else { _error('Not a valid action, expected CASCADE, SET NULL, etc..'); } } List _listColumnsInParentheses({bool allowEmpty = false}) { final columnNames = []; if (_matchOne(TokenType.leftParen)) { do { final referenceId = _consumeIdentifier('Expected a column name'); final reference = Reference(columnName: referenceId.identifier) ..setSpan(referenceId, referenceId); columnNames.add(reference); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing paranthesis after column names'); } else { if (!allowEmpty) { _error('Expected a list of columns in parantheses'); } } return columnNames; } } extension on List { String get lexeme => first.span.expand(last.span).text; } lib/src/reader/tokenizer 755 0 0 0 0 13035 5ustar0 pubpublib/src/reader/tokenizer/utils.dart 644 0 0 1035 14345646642 15524 0ustar0 pubpubimport 'package:charcode/ascii.dart'; bool isDigit(int charCode) { return $0 <= charCode && charCode <= $9; } bool isHexDigit(int charCode) { return ($a <= charCode && charCode <= $f) || ($A <= charCode && charCode <= $F) || ($0 <= charCode && charCode <= $9); } bool canStartIdentifier(int charCode) { return charCode == $_ || ($a <= charCode && charCode <= $z) || ($A <= charCode && charCode <= $Z); } bool continuesIdentifier(int charCode) { return canStartIdentifier(charCode) || isDigit(charCode); } lib/src/reader/tokenizer/token.dart 644 0 0 40144 14711507160 15514 0ustar0 pubpubimport 'dart:math'; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; enum TokenType { /// A token representing an invalid lexeme in the source. errorToken, $case, $default, $do, $else, $false, $for, $if, $in, $index, $is, $null, $true, $values, $with, abort, action, add, after, all, alter, always, ampersand, analyze, and, any, array, as, asc, asymmetric, atSignVariable, attach, autoincrement, before, begin, between, binary, both, by, cascade, cast, check, collate, colon, column, colonVariable, comma, comment, commit, conflict, constraint, create, cross, current, currentDate, currentTime, currentTimestamp, currentUser, database, /// `->`, extract subcomponent of JSON dashRangle, /// `->>`, extract subcomponent of JSON as SQL value. dashRangleRangle, deferrable, deferred, delete, desc, detach, distinct, dollarSignVariable, dot, doubleEqual, doublePipe, drop, each, end, eof, equal, escape, except, exclamationEqual, exclude, exclusive, exists, explain, fail, filter, first, following, foreign, from, full, generated, glob, grant, group, groups, having, identifier, ignore, ilike, immediate, indexed, initially, inner, insert, instead, intersect, into, isNull, join, key, last, leading, left, leftParen, less, lessEqual, lessMore, like, limit, localTime, localTimestamp, match, materialized, minus, more, moreEqual, natural, no, not, notNull, nothing, nulls, numberLiteral, of, offset, on, only, or, order, others, outer, over, overlaps, partition, placing, percent, pipe, plan, plus, pragma, preceding, primary, query, questionMarkVariable, range, raise, recursive, references, regexp, reindex, release, rename, replace, returning, restrict, right, rightParen, rollback, row, rowid, rows, savepoint, select, semicolon, set, sessionUser, shiftLeft, shiftRight, similar, slash, some, stored, star, strict, symmetric, stringLiteral, table, temp, temporary, then, ties, tilde, to, trailing, transaction, trigger, unbounded, union, unique, update, user, using, vacuum, view, virtual, when, where, window, without, /// Drift specific token, used to declare type converter mapped, inlineDart, import, json, required, list, /// A `**` token. This is only scanned when scanning for drift tokens. doubleStar, } const Map keywords = { 'ADD': TokenType.add, 'ABORT': TokenType.abort, 'ACTION': TokenType.action, 'AFTER': TokenType.after, 'ALL': TokenType.all, 'ALTER': TokenType.alter, 'ALWAYS': TokenType.always, 'ANALYZE': TokenType.analyze, 'AND': TokenType.and, 'AS': TokenType.as, 'ASC': TokenType.asc, 'ATTACH': TokenType.attach, 'AUTOINCREMENT': TokenType.autoincrement, 'BEFORE': TokenType.before, 'BEGIN': TokenType.begin, 'BETWEEN': TokenType.between, 'BY': TokenType.by, 'CASCADE': TokenType.cascade, 'CASE': TokenType.$case, 'CAST': TokenType.cast, 'CHECK': TokenType.check, 'COLLATE': TokenType.collate, 'COLUMN': TokenType.column, 'COMMIT': TokenType.commit, 'CONFLICT': TokenType.conflict, 'CONSTRAINT': TokenType.constraint, 'CREATE': TokenType.create, 'CROSS': TokenType.cross, 'CURRENT': TokenType.current, 'CURRENT_DATE': TokenType.currentDate, 'CURRENT_TIME': TokenType.currentTime, 'CURRENT_TIMESTAMP': TokenType.currentTimestamp, 'DATABASE': TokenType.database, 'DEFAULT': TokenType.$default, 'DEFERRABLE': TokenType.deferrable, 'DEFERRED': TokenType.deferred, 'DELETE': TokenType.delete, 'DESC': TokenType.desc, 'DETACH': TokenType.detach, 'DISTINCT': TokenType.distinct, 'DO': TokenType.$do, 'DROP': TokenType.drop, 'EACH': TokenType.each, 'ELSE': TokenType.$else, 'END': TokenType.end, 'ESCAPE': TokenType.escape, 'EXCEPT': TokenType.except, 'EXCLUDE': TokenType.exclude, 'EXCLUSIVE': TokenType.exclusive, 'EXISTS': TokenType.exists, 'EXPLAIN': TokenType.explain, 'FAIL': TokenType.fail, 'FALSE': TokenType.$false, 'FILTER': TokenType.filter, 'FIRST': TokenType.first, 'FOLLOWING': TokenType.following, 'FOR': TokenType.$for, 'FOREIGN': TokenType.foreign, 'FROM': TokenType.from, 'FULL': TokenType.full, 'GENERATED': TokenType.generated, 'GLOB': TokenType.glob, 'GROUP': TokenType.group, 'GROUPS': TokenType.groups, 'HAVING': TokenType.having, 'IF': TokenType.$if, 'IGNORE': TokenType.ignore, 'IMMEDIATE': TokenType.immediate, 'IN': TokenType.$in, 'INDEX': TokenType.$index, 'INDEXED': TokenType.indexed, 'INITIALLY': TokenType.initially, 'INNER': TokenType.inner, 'INSERT': TokenType.insert, 'INSTEAD': TokenType.instead, 'INTERSECT': TokenType.intersect, 'INTO': TokenType.into, 'IS': TokenType.$is, 'ISNULL': TokenType.isNull, 'JOIN': TokenType.join, 'KEY': TokenType.key, 'LAST': TokenType.last, 'LEADING': TokenType.leading, 'LEFT': TokenType.left, 'LIKE': TokenType.like, 'LIMIT': TokenType.limit, 'MATCH': TokenType.match, 'MATERIALIZED': TokenType.materialized, 'NATURAL': TokenType.natural, 'NO': TokenType.no, 'NOT': TokenType.not, 'NOTHING': TokenType.nothing, 'NOTNULL': TokenType.notNull, 'NULL': TokenType.$null, 'NULLS': TokenType.nulls, 'OF': TokenType.of, 'OFFSET': TokenType.offset, 'ON': TokenType.on, 'OR': TokenType.or, 'ORDER': TokenType.order, 'OTHERS': TokenType.others, 'OUTER': TokenType.outer, 'OVER': TokenType.over, 'PARTITION': TokenType.partition, 'PLAN': TokenType.plan, 'PRAGMA': TokenType.pragma, 'PRECEDING': TokenType.preceding, 'PRIMARY': TokenType.primary, 'QUERY': TokenType.query, 'RAISE': TokenType.raise, 'RANGE': TokenType.range, 'RECURSIVE': TokenType.recursive, 'REFERENCES': TokenType.references, 'REGEXP': TokenType.regexp, 'REINDEX': TokenType.reindex, 'RELEASE': TokenType.release, 'RENAME': TokenType.rename, 'REPLACE': TokenType.replace, 'RIGHT': TokenType.right, 'RETURNING': TokenType.returning, 'RESTRICT': TokenType.restrict, 'ROLLBACK': TokenType.rollback, 'ROW': TokenType.row, 'ROWID': TokenType.rowid, 'ROWS': TokenType.rows, 'SAVEPOINT': TokenType.savepoint, 'SELECT': TokenType.select, 'SET': TokenType.set, 'STORED': TokenType.stored, 'STRICT': TokenType.strict, 'TABLE': TokenType.table, 'TEMP': TokenType.temp, 'TEMPORARY': TokenType.temporary, 'THEN': TokenType.then, 'TIES': TokenType.ties, 'TO': TokenType.to, 'TRANSACTION': TokenType.transaction, 'TRIGGER': TokenType.trigger, 'TRUE': TokenType.$true, 'UNBOUNDED': TokenType.unbounded, 'UNION': TokenType.union, 'UNIQUE': TokenType.unique, 'UPDATE': TokenType.update, 'USING': TokenType.using, 'VACUUM': TokenType.vacuum, 'VALUES': TokenType.$values, 'VIEW': TokenType.view, 'VIRTUAL': TokenType.virtual, 'WHEN': TokenType.when, 'WHERE': TokenType.where, 'WINDOW': TokenType.window, 'WITH': TokenType.$with, 'WITHOUT': TokenType.without, }; const Map postgresKeywords = { 'ANY': TokenType.any, 'ARRAY': TokenType.array, 'ASYMMETRIC': TokenType.asymmetric, 'BINARY': TokenType.binary, 'BOTH': TokenType.both, 'CURRENT_USER': TokenType.currentUser, 'ILIKE': TokenType.ilike, 'LEADING': TokenType.leading, 'LOCALTIME': TokenType.localTime, 'LOCALTIMESTAMP': TokenType.localTimestamp, 'GRANT': TokenType.grant, 'ONLY': TokenType.only, 'OVERLAPS': TokenType.overlaps, 'PLACING': TokenType.placing, 'SESSION_USER': TokenType.sessionUser, 'SIMILAR': TokenType.similar, 'SOME': TokenType.some, 'SYMMETRIC': TokenType.symmetric, 'TRAILING': TokenType.trailing, 'USER': TokenType.user, }; /// Maps [TokenType]s which are keywords to their lexeme. final Map reverseKeywords = { for (var entry in keywords.entries) entry.value: entry.key, for (var entry in driftKeywords.entries) entry.value: entry.key, }; const Map driftKeywords = { 'IMPORT': TokenType.import, 'JSON': TokenType.json, 'MAPPED': TokenType.mapped, 'REQUIRED': TokenType.required, 'LIST': TokenType.list, }; /// A set of [TokenType]s that can be parsed as an identifier. const Set _identifierKeywords = { TokenType.join, TokenType.rowid, }; /// Returns true if the [type] belongs to a keyword bool isKeyword(TokenType type) => reverseKeywords.containsKey(type); /// Returns true if [name] is a reserved keyword in sqlite. bool isKeywordLexeme(String name) => keywords.containsKey(name.toUpperCase()); /// Returns true if [name] is a reserved keyword in postgres. bool isPostgresKeywordLexeme(String name) => postgresKeywords.containsKey(name.toUpperCase()); class Token implements SyntacticEntity { final TokenType type; /// Whether this token should be invisible to the parser. We use this for /// comment tokens. bool get invisibleToParser => false; @override final FileSpan span; String get lexeme => span.text; /// The index of this [Token] in the list of tokens scanned. late int index; Token? previous, next; /// For opening tokens (e.g. `(`), the matching closing token (`)`), and /// vice-versa. /// /// This information can be used to improve error recovery in the parser /// later. Token? match; Token(this.type, this.span); @override bool get hasSpan => true; @override String toString() { return '$type: $lexeme'; } @override int get firstPosition => span.start.offset; @override int get lastPosition => span.end.offset; @override bool get synthetic => false; } class StringLiteralToken extends Token { final String value; /// sqlite allows binary strings (x'literal') which are interpreted as blobs. final bool binary; StringLiteralToken(this.value, FileSpan span, {this.binary = false}) : super(TokenType.stringLiteral, span); } class IdentifierToken extends Token { /// Whether this identifier was escaped by putting it in "double ticks". final bool escaped; /// Whether this identifier token is synthetic. We sometimes convert /// [KeywordToken]s to identifiers if they're unambiguous, in which case /// [synthetic] will be true on this token because it was not scanned as such. @override final bool synthetic; String get identifier { if (escaped) { return lexeme.substring(1, lexeme.length - 1); } else { return lexeme; } } IdentifierToken(this.escaped, FileSpan span, {this.synthetic = false}) : super(TokenType.identifier, span); } abstract class VariableToken extends Token { VariableToken(super.type, super.span); } class QuestionMarkVariableToken extends Token { /// The explicit index, if this variable was of the form `?123`. Otherwise /// null. final int? explicitIndex; QuestionMarkVariableToken(FileSpan span, this.explicitIndex) : super(TokenType.questionMarkVariable, span); } class ColonVariableToken extends Token { final String name; ColonVariableToken(FileSpan span, this.name) : super(TokenType.colonVariable, span); } class DollarSignVariableToken extends Token { final String name; DollarSignVariableToken(FileSpan span, this.name) : super(TokenType.dollarSignVariable, span); } class AtSignVariableToken extends Token { final String name; AtSignVariableToken(FileSpan span, this.name) : super(TokenType.atSignVariable, span); } /// Inline Dart appearing in a create table statement. Only parsed when the /// drift extensions are enabled. Dart code is wrapped in backticks. class InlineDartToken extends Token { InlineDartToken(FileSpan span) : super(TokenType.inlineDart, span); String get dartCode { // strip the backticks return lexeme.substring(1, lexeme.length - 1); } } /// Used for tokens that are keywords. We use this special class without any /// additional properties to ease syntax highlighting, as it allows us to find /// the keywords easily. class KeywordToken extends Token { /// Whether this token has been used as an identifier while parsing. bool isIdentifier = false; KeywordToken(super.type, super.span); bool canConvertToIdentifier() { // https://stackoverflow.com/a/45775719, but we don't parse indexed yet. return _identifierKeywords.contains(type) || driftKeywords.values.contains(type); } IdentifierToken convertToIdentifier() { isIdentifier = true; return IdentifierToken(false, span, synthetic: true); } } /// Used to represent additional information of [TokenType.numberLiteral]. /// /// For more details, see the docs on https://www.sqlite.org/syntax/numeric-literal.html class NumericToken extends Token { /// The digits before the decimal point, or null if this numeric token was /// written in hexadecimal notation or started with a decimal point. String? digitsBeforeDecimal; /// Whether this token has a decimal point in it. bool hasDecimalPoint; /// The digits after the decimal point, or null if this numeric token doesn't /// have anything after its decimal point. String? digitsAfterDecimal; /// The hexadecimal digits of this token, or null if this token was not in /// hex notation. String? hexDigits; /// An exponent to the base of ten. /// /// For instance, `2E-2` has an [exponent] of `-2`. final int? exponent; NumericToken( FileSpan span, { this.digitsBeforeDecimal, this.hasDecimalPoint = false, this.digitsAfterDecimal, this.hexDigits, this.exponent, }) : super(TokenType.numberLiteral, span); /// The numeric literal represented by this token. num get parsedNumber { if (hexDigits != null) { return int.parse(hexDigits!, radix: 16); } final beforeDecimal = digitsBeforeDecimal != null ? int.parse(digitsBeforeDecimal!) : 0; num number; if (!hasDecimalPoint) { number = beforeDecimal; } else if (digitsAfterDecimal != null) { number = beforeDecimal + double.parse('.$digitsAfterDecimal'); } else { // Is of the form 3., so just infer as double number = beforeDecimal.toDouble(); } if (exponent != null) { number *= pow(10, exponent!); } return number; } @visibleForTesting bool hasSameStructureAs(NumericToken other) { return other.digitsBeforeDecimal == digitsBeforeDecimal && other.hasDecimalPoint == hasDecimalPoint && other.digitsAfterDecimal == digitsAfterDecimal && other.hexDigits == hexDigits && other.exponent == exponent; } @override String toString() { final buffer = StringBuffer(); if (hexDigits != null) { buffer ..write('0x') ..write(hexDigits); } else { if (digitsBeforeDecimal != null) { buffer.write(digitsBeforeDecimal); } if (hasDecimalPoint) { buffer.write('.'); } if (digitsAfterDecimal != null) { buffer.write(digitsAfterDecimal); } if (exponent != null) { buffer ..write('E') ..write(exponent); } } return buffer.toString(); } } enum CommentMode { line, cStyle } /// A comment, either started with -- or with /*. class CommentToken extends Token { final CommentMode mode; /// The content of this comment, excluding the "--", "/*", "*/". final String content; @override final bool invisibleToParser = true; CommentToken(this.mode, this.content, FileSpan span) : super(TokenType.comment, span); } class TokenizerError extends Token { final String message; final FileLocation location; TokenizerError(this.message, this.location) : super(TokenType.errorToken, location.pointSpan()); @override String toString() { return '$message at $location'; } } /// Thrown by the sql engine when a sql statement can't be tokenized. class CumulatedTokenizerException implements Exception { final List errors; CumulatedTokenizerException(this.errors); @override String toString() { final explanation = errors.map((e) => '${e.message} at ${e.location}').join(', '); return 'Malformed sql: $explanation'; } } lib/src/reader/tokenizer/scanner.dart 644 0 0 35716 14711507160 16036 0ustar0 pubpubimport 'dart:typed_data'; import 'package:charcode/charcode.dart'; import 'package:source_span/source_span.dart'; import 'token.dart'; import 'utils.dart'; class Scanner { final String source; final Uint16List _charCodes; /// Whether to scan tokens that are only relevant for drift files. final bool scanDriftTokens; final SourceFile _file; final List tokens = []; final List errors = []; /// Pending opening tokens used to associate them with closing tokens. /// /// This used to pair matching parentheses, as the information can be used by /// the parser to be more accurate about error recovery. /// An entry in the stack is the opening token and the token type closing that /// token. final List<(Token, TokenType)> _tokenStack = []; int _startOffset = 0; int _currentOffset = 0; bool get _isAtEnd => _currentOffset >= source.length; FileSpan get _currentSpan { return _file.span(_startOffset, _currentOffset); } FileLocation get _currentLocation { return _file.location(_currentOffset); } Scanner(this.source, {this.scanDriftTokens = false}) : _file = SourceFile.fromString(source), _charCodes = Uint16List.fromList(source.codeUnits); List scanTokens() { while (!_isAtEnd) { _startOffset = _currentOffset; _scanToken(); } final endSpan = _file.span(source.length); tokens.add(Token(TokenType.eof, endSpan)); Token? previous; for (var i = 0; i < tokens.length; i++) { final current = tokens[i]; current.index = i; current.previous = previous; previous?.next = current; previous = current; } return tokens; } void _scanToken() { final char = _nextChar(); switch (char) { case $lparen: _addToken(TokenType.leftParen, closedBy: TokenType.rightParen); break; case $rparen: _addToken(TokenType.rightParen, mayClose: true); break; case $comma: _addToken(TokenType.comma); break; case $dot: if (!_isAtEnd && isDigit(_peek())) { _numeric(char); } else { _addToken(TokenType.dot); } break; case $plus: _addToken(TokenType.plus); break; case $minus: if (_match($minus)) { _lineComment(); } else if (_match($rangle)) { _addToken(_match($rangle) ? TokenType.dashRangleRangle : TokenType.dashRangle); } else { _addToken(TokenType.minus); } break; case $asterisk: if (scanDriftTokens && _match($asterisk)) { _addToken(TokenType.doubleStar); } else { _addToken(TokenType.star); } break; case $slash: if (_match($asterisk)) { _cStyleComment(); } else { _addToken(TokenType.slash); } break; case $percent: _addToken(TokenType.percent); break; case $ampersand: _addToken(TokenType.ampersand); break; case $pipe: _addToken(_match($pipe) ? TokenType.doublePipe : TokenType.pipe); break; case $less_than: if (_match($equal)) { _addToken(TokenType.lessEqual); } else if (_match($less_than)) { _addToken(TokenType.shiftLeft); } else if (_match($greater_than)) { _addToken(TokenType.lessMore); } else { _addToken(TokenType.less); } break; case $greater_than: if (_match($equal)) { _addToken(TokenType.moreEqual); } else if (_match($greater_than)) { _addToken(TokenType.shiftRight); } else { _addToken(TokenType.more); } break; case $exclamation: if (_match($equal)) { _addToken(TokenType.exclamationEqual); } else { _unexpectedToken(); } break; case $equal: _addToken(_match($equal) ? TokenType.doubleEqual : TokenType.equal); break; case $tilde: _addToken(TokenType.tilde); break; case $question: // if the next chars are numbers, this is an explicitly indexed variable final buffer = StringBuffer(); while (!_isAtEnd && isDigit(_peek())) { buffer.writeCharCode(_nextChar()); } int? explicitIndex; if (buffer.isNotEmpty) { explicitIndex = int.parse(buffer.toString()); } tokens.add(QuestionMarkVariableToken(_currentSpan, explicitIndex)); break; case $colon: final name = _matchColumnName(); if (name == null) { _addToken(TokenType.colon); } else { tokens.add(ColonVariableToken(_currentSpan, ':$name')); } break; case $dollar: final name = _matchColumnName(); if (name == null) { errors.add(TokenizerError( r'Expected identifier after `$`', _currentLocation)); break; } tokens.add(DollarSignVariableToken(_currentSpan, name)); break; case $at: final name = _matchColumnName(); if (name == null) { errors.add(TokenizerError( r'Expected identifier after `@`', _currentLocation)); break; } tokens.add(AtSignVariableToken(_currentSpan, name)); break; case $semicolon: _addToken(TokenType.semicolon); _tokenStack.clear(); break; case $x: case $X: if (_match($apostrophe)) { _string(binary: true); } else { _identifier(); } break; case $apostrophe: _string(); break; case $double_quote: _identifier(escapeChar: $double_quote); break; case $backquote: if (scanDriftTokens) { _inlineDart(); } else { _identifier(escapeChar: $backquote); } break; case $lbracket: _identifier(escapeChar: $rbracket); break; case $space: case $cr: case $tab: case $lf: // ignore whitespace break; default: if (isDigit(char)) { _numeric(char); } else if (canStartIdentifier(char)) { _identifier(); } else { _unexpectedToken(); } break; } } void _unexpectedToken() { errors.add(TokenizerError('Unexpected character', _currentLocation)); } int _nextChar() { _advance(); return _charCodes[_currentOffset - 1]; } void _advance() => _currentOffset++; int _peek() { if (_isAtEnd) throw StateError('Reached end of source'); return _charCodes[_currentOffset]; } bool _match(int expected) { if (_isAtEnd) return false; if (_peek() != expected) { return false; } _currentOffset++; return true; } void _addToken( TokenType type, { TokenType? closedBy, bool mayClose = false, }) { final token = Token(type, _currentSpan); tokens.add(token); if (closedBy != null) { _tokenStack.add((token, closedBy)); } if (mayClose && _tokenStack.isNotEmpty) { final candidate = _tokenStack.removeLast(); if (candidate.$2 == type) { candidate.$1.match = token; token.match = candidate.$1; } else { // Stack association broken, nothing we can do... _tokenStack.clear(); } } } void _string({bool binary = false}) { var properlyClosed = false; while (!_isAtEnd) { final char = _nextChar(); // single quote could be an escape (when there are two of them) or the // end of this string literal if (char == $apostrophe) { if (!_isAtEnd && _peek() == $apostrophe) { _advance(); continue; } properlyClosed = true; break; } } // Issue an error if the string is unterminated if (!properlyClosed) { errors.add(TokenizerError('Unterminated string', _currentLocation)); } final value = source .substring(_startOffset + (binary ? 2 : 1), _currentOffset - 1) .replaceAll("''", "'"); tokens.add(StringLiteralToken(value, _currentSpan, binary: binary)); } void _numeric(int firstChar) { // https://www.sqlite.org/syntax/numeric-literal.html /// Recognizes either a digit or a underscore followed by a digit. int? digitCode(bool Function(int) isDigit) { if (_isAtEnd) { return null; } if (isDigit(_peek())) { // Digit without an underscore separator return _nextChar(); } if (_peek() == $underscore && _currentOffset < _charCodes.length - 1 && isDigit(_charCodes[_currentOffset + 1])) { _nextChar(); // the underscore return _nextChar(); // the digit } return null; } // We basically have three cases: hexadecimal numbers (starting with 0x), // numbers starting with a decimal dot and numbers starting with a digit. if (firstChar == $0) { if (!_isAtEnd && (_peek() == $x || _peek() == $X)) { _nextChar(); // consume the x final hexDigitsBuffer = StringBuffer(); // advance hexadecimal digits int? digit = digitCode(isHexDigit); while (digit != null) { hexDigitsBuffer.writeCharCode(digit); digit = digitCode(isHexDigit); } tokens.add( NumericToken(_currentSpan, hexDigits: hexDigitsBuffer.toString())); return; } } String consumeDigits() { final buffer = StringBuffer(); int? digit = digitCode(isDigit); while (digit != null) { buffer.writeCharCode(digit); digit = digitCode(isDigit); } return buffer.toString(); } /// Returns true without advancing if the next char is a digit. Returns /// false and logs an error with the message otherwise. bool requireDigit(String message) { final noDigit = _isAtEnd || !isDigit(_peek()); if (noDigit) { errors.add(TokenizerError(message, _currentLocation)); } return !noDigit; } String? beforeDecimal; String? afterDecimal; var hasDecimal = false; // ok, we're not dealing with a hexadecimal number. if (firstChar == $dot) { // started with a decimal point. the next char has to be numeric hasDecimal = true; if (requireDigit('Expected a digit after the decimal dot')) { afterDecimal = consumeDigits(); } } else { // ok, not starting with a decimal dot. In that case, the first char must // be a digit if (!isDigit(firstChar)) { errors.add(TokenizerError('Expected a digit', _currentLocation)); return; } beforeDecimal = String.fromCharCode(firstChar) + consumeDigits(); // optional decimal part if (!_isAtEnd && _peek() == $dot) { _nextChar(); hasDecimal = true; final digits = consumeDigits(); if (digits.isNotEmpty) { afterDecimal = digits; } } } int? parsedExponent; // ok, we've read the first part of the number. But there's more! If it's // not a hexadecimal number, it could be in scientific notation. if (!_isAtEnd && (_peek() == $e || _peek() == $E)) { _nextChar(); // consume e or E if (_isAtEnd) { errors.add(TokenizerError( 'Unexpected end of file. ' 'Expected digits for the scientific notation', _currentLocation)); return; } final char = _nextChar(); if (isDigit(char)) { final exponent = String.fromCharCode(char) + consumeDigits(); parsedExponent = int.parse(exponent); } else { if (char == $plus || char == $minus) { requireDigit('Expected digits for the exponent'); final exponent = consumeDigits(); parsedExponent = char == $plus ? int.parse(exponent) : -int.parse(exponent); } else { errors .add(TokenizerError('Expected plus or minus', _currentLocation)); } } } tokens.add(NumericToken(_currentSpan, digitsBeforeDecimal: beforeDecimal, digitsAfterDecimal: afterDecimal, hasDecimalPoint: hasDecimal, exponent: parsedExponent)); } void _identifier({int? escapeChar}) { if (escapeChar != null) { // find the closing quote while (!_isAtEnd && _peek() != escapeChar) { _nextChar(); } // Issue an error if the column name is unterminated if (_isAtEnd) { errors .add(TokenizerError('Unterminated column name', _currentLocation)); } else { // consume the closing char _nextChar(); tokens.add(IdentifierToken(true, _currentSpan)); } } else { while (!_isAtEnd && continuesIdentifier(_peek())) { _nextChar(); } // not escaped, so it could be a keyword final text = _currentSpan.text.toUpperCase(); if (keywords.containsKey(text)) { tokens.add(KeywordToken(keywords[text]!, _currentSpan)); } else if (scanDriftTokens && driftKeywords.containsKey(text)) { tokens.add(KeywordToken(driftKeywords[text]!, _currentSpan)); } else { tokens.add(IdentifierToken(false, _currentSpan)); } } } String? _matchColumnName() { if (_isAtEnd || !canStartIdentifier(_peek())) return null; final buffer = StringBuffer()..writeCharCode(_nextChar()); while (!_isAtEnd && continuesIdentifier(_peek())) { buffer.writeCharCode(_nextChar()); } return buffer.toString(); } void _inlineDart() { // inline starts with a `, we just need to find the matching ` that // terminates this token. while (_peek() != $backquote && !_isAtEnd) { _nextChar(); } if (_isAtEnd) { errors.add( TokenizerError('Unterminated inline Dart code', _currentLocation)); } else { // consume the ` _nextChar(); tokens.add(InlineDartToken(_currentSpan)); } } /// Scans a line comment after the -- has already been read. void _lineComment() { final contentBuilder = StringBuffer(); while (!_isAtEnd && _peek() != $lf) { contentBuilder.writeCharCode(_nextChar()); } tokens.add(CommentToken( CommentMode.line, contentBuilder.toString(), _currentSpan)); } /// Scans a /* ... */ comment after the first /* has already been read. /// Note that in sqlite, these comments don't have to be terminated - they /// will be closed by the end of input without causing a parsing error. void _cStyleComment() { final contentBuilder = StringBuffer(); while (!_isAtEnd) { if (_match($asterisk)) { if (!_isAtEnd && _match($slash)) { break; } else { // write the * we otherwise forgot to write contentBuilder.writeCharCode($asterisk); } } else { contentBuilder.writeCharCode(_nextChar()); } } tokens.add(CommentToken( CommentMode.cStyle, contentBuilder.toString(), _currentSpan)); } } lib/src/ast 755 0 0 0 0 10350 5ustar0 pubpublib/src/ast/node.dart 644 0 0 11370 14354624632 12642 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/reader/syntactic_entity.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:sqlparser/src/utils/meta.dart'; import 'ast.dart'; // todo: Remove this import after untangling the library /// A node in the abstract syntax tree of an SQL statement. abstract class AstNode with HasMetaMixin implements SyntacticEntity { /// The parent of this node, or null if this is the root node. Will be set /// by the analyzer after the tree has been parsed. AstNode? parent; /// The first token that appears in this node. This information is not set for /// all nodes. Token? first; /// The last token that appears in this node. This information is not set for /// all nodes. Token? last; @override bool synthetic = false; @override int get firstPosition => first!.span.start.offset; @override int get lastPosition => last!.span.end.offset; @override FileSpan? get span { if (!hasSpan) return null; return first!.span.expand(last!.span); } @override bool get hasSpan => first != null && last != null; /// Sets the [AstNode.first] and [AstNode.last] property in one go. void setSpan(Token first, Token last) { this.first = first; this.last = last; } /// Returns all parents of this node up to the root. If this node is the root, /// the iterable will be empty. Iterable get parents sync* { var node = parent; while (node != null) { yield node; node = node.parent; } } /// Returns an iterable containing `this` node and all [parents]. Iterable get selfAndParents sync* { yield this; yield* parents; } /// Recursively returns all descendants of this node, e.g. its children, their /// children and so on. The tree will be pre-order traversed. Iterable get allDescendants sync* { for (final child in childNodes) { yield child; yield* child.allDescendants; } } /// Returns an iterable that fields yields this node, followed by /// [allDescendants]. Iterable get selfAndDescendants sync* { yield this; yield* allDescendants; } bool isChildOf(AstNode other) => parents.contains(other); /// Finds the first element in [selfAndParents] of the type [T]. /// /// Returns `null` if there's no node of type [T] surrounding this ast node. T? enclosingOfType() { for (final element in selfAndParents) { if (element is T) { return element; } } return null; } ReferenceScope? get optionalScope { AstNode? node = this; while (node != null) { final scope = node.meta(); if (scope != null) return scope; node = node.parent; } return null; } /// The [ReferenceScope], which contains available tables, column references /// and functions for this node. ReferenceScope get scope { final resolved = optionalScope; if (resolved != null) return resolved; throw StateError('No reference scope found in this or any parent node'); } StatementScope get statementScope => StatementScope.cast(scope); /// Applies a [ReferenceScope] to this node. Variables declared in [scope] /// will be visible to this node and to [allDescendants]. set scope(ReferenceScope scope) { setMeta(scope); } /// All direct children of this node. Iterable get childNodes; /// Calls the appropriate method on the [visitor] to make it recognize this /// node. R accept(AstVisitor visitor, A arg); /// Like [accept], but without an argument. /// /// Null will be used for the argument instead. R acceptWithoutArg(AstVisitor visitor) { return accept(visitor, null); } /// Transforms children of this node by invoking [transformer] with the /// argument [arg]. void transformChildren(Transformer transformer, A arg); /// Whether the content of this node is equal to the [other] node of the same /// type. The "content" refers to anything stored only in this node, children /// are ignored. @nonVirtual bool contentEquals(AstNode other) { final checker = EqualityEnforcingVisitor(this, considerChildren: false); try { checker.visit(other, null); return true; } on NotEqualException { return false; } } @override String toString() { if (hasSpan) { return '$runtimeType: ${span!.text}'; } return super.toString(); } } /// Common interface for every node that has a `where` clause. abstract class HasWhereClause implements AstNode { Expression? get where; } lib/src/ast/visitor.dart 644 0 0 41414 14612235271 13410 0ustar0 pubpubimport 'ast.dart'; abstract class AstVisitor { R visitSelectStatement(SelectStatement e, A arg); R visitCompoundSelectStatement(CompoundSelectStatement e, A arg); R visitCompoundSelectPart(CompoundSelectPart e, A arg); R visitValuesSelectStatement(ValuesSelectStatement e, A arg); R visitInsertStatement(InsertStatement e, A arg); R visitDeleteStatement(DeleteStatement e, A arg); R visitUpdateStatement(UpdateStatement e, A arg); R visitCreateTableStatement(CreateTableStatement e, A arg); R visitCreateVirtualTableStatement(CreateVirtualTableStatement e, A arg); R visitCreateTriggerStatement(CreateTriggerStatement e, A arg); R visitCreateIndexStatement(CreateIndexStatement e, A arg); R visitCreateViewStatement(CreateViewStatement e, A arg); R visitInvalidStatement(InvalidStatement e, A arg); R visitReturning(Returning e, A arg); R visitWithClause(WithClause e, A arg); R visitUpsertClause(UpsertClause e, A arg); R visitUpsertClauseEntry(UpsertClauseEntry e, A arg); R visitCommonTableExpression(CommonTableExpression e, A arg); R visitOrderBy(OrderBy e, A arg); R visitOrderingTerm(OrderingTerm e, A arg); R visitLimit(Limit e, A arg); R visitStarResultColumn(StarResultColumn e, A arg); R visitExpressionResultColumn(ExpressionResultColumn e, A arg); R visitTableReference(TableReference e, A arg); R visitSelectStatementAsSource(SelectStatementAsSource e, A arg); R visitJoinClause(JoinClause e, A arg); R visitJoinOperator(JoinOperator e, A arg); R visitTableValuedFunction(TableValuedFunction e, A arg); R visitJoin(Join e, A arg); R visitGroupBy(GroupBy e, A arg); R visitDeleteTriggerTarget(DeleteTarget e, A arg); R visitInsertTriggerTarget(InsertTarget e, A arg); R visitUpdateTriggerTarget(UpdateTarget e, A arg); R visitDoNothing(DoNothing e, A arg); R visitDoUpdate(DoUpdate e, A arg); R visitSingleColumnSetComponent(SingleColumnSetComponent e, A arg); R visitMultiColumnSetComponent(MultiColumnSetComponent e, A arg); R visitValuesSource(ValuesSource e, A arg); R visitSelectInsertSource(SelectInsertSource e, A arg); R visitDefaultValues(DefaultValues e, A arg); R visitColumnDefinition(ColumnDefinition e, A arg); R visitColumnConstraint(ColumnConstraint e, A arg); R visitTableConstraint(TableConstraint e, A arg); R visitForeignKeyClause(ForeignKeyClause e, A arg); R visitDeferrableClause(DeferrableClause e, A arg); R visitNumericLiteral(NumericLiteral e, A arg); R visitNullLiteral(NullLiteral e, A arg); R visitBooleanLiteral(BooleanLiteral e, A arg); R visitStringLiteral(StringLiteral e, A arg); R visitTimeConstantLiteral(TimeConstantLiteral e, A arg); R visitCastExpression(CastExpression e, A arg); R visitBinaryExpression(BinaryExpression e, A arg); R visitStringComparison(StringComparisonExpression e, A arg); R visitCollateExpression(CollateExpression e, A arg); R visitUnaryExpression(UnaryExpression e, A arg); R visitIsExpression(IsExpression e, A arg); R visitIsNullExpression(IsNullExpression e, A arg); R visitBetweenExpression(BetweenExpression e, A arg); R visitReference(Reference e, A arg); R visitFunction(FunctionExpression e, A arg); R visitStarFunctionParameter(StarFunctionParameter e, A arg); R visitExpressionFunctionParameters(ExprFunctionParameters e, A arg); R visitSubQuery(SubQuery e, A arg); R visitExists(ExistsExpression e, A arg); R visitCaseExpression(CaseExpression e, A arg); R visitWhen(WhenComponent e, A arg); R visitTuple(Tuple e, A arg); R visitParentheses(Parentheses e, A arg); R visitInExpression(InExpression e, A arg); R visitRaiseExpression(RaiseExpression e, A arg); R visitAggregateFunctionInvocation(AggregateFunctionInvocation e, A arg); R visitWindowFunctionInvocation(WindowFunctionInvocation e, A arg); R visitWindowDefinition(WindowDefinition e, A arg); R visitFrameSpec(FrameSpec e, A arg); R visitIndexedColumn(IndexedColumn e, A arg); R visitNumberedVariable(NumberedVariable e, A arg); R visitNamedVariable(ColonNamedVariable e, A arg); R visitBlock(Block block, A arg); R visitSemicolonSeparatedStatements(SemicolonSeparatedStatements e, A arg); R visitBeginTransaction(BeginTransactionStatement e, A arg); R visitCommitStatement(CommitStatement e, A arg); R visitDriftSpecificNode(DriftSpecificNode e, A arg); } /// Visitor that walks down the entire tree, visiting all children in order. class RecursiveVisitor implements AstVisitor { // Statements @override R? visitInvalidStatement(InvalidStatement e, A arg) { return visitStatement(e, arg); } @override R? visitSelectStatement(SelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitValuesSelectStatement(ValuesSelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitCompoundSelectStatement(CompoundSelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitInsertStatement(InsertStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitDeleteStatement(DeleteStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitUpdateStatement(UpdateStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitCreateTableStatement(CreateTableStatement e, A arg) { return visitTableInducingStatement(e, arg); } @override R? visitCreateVirtualTableStatement(CreateVirtualTableStatement e, A arg) { return visitTableInducingStatement(e, arg); } @override R? visitCreateViewStatement(CreateViewStatement e, A arg) { return visitSchemaStatement(e, arg); } @override R? visitCreateTriggerStatement(CreateTriggerStatement e, A arg) { return visitSchemaStatement(e, arg); } @override R? visitCreateIndexStatement(CreateIndexStatement e, A arg) { return visitSchemaStatement(e, arg); } R? visitBaseSelectStatement(BaseSelectStatement stmt, A arg) { return visitCrudStatement(stmt, arg); } R? visitCrudStatement(CrudStatement stmt, A arg) { return visitStatement(stmt, arg); } R? visitTableInducingStatement(TableInducingStatement stmt, A arg) { return visitSchemaStatement(stmt, arg); } R? visitSchemaStatement(SchemaStatement stmt, A arg) { return visitStatement(stmt, arg); } R? visitStatement(Statement statement, A arg) { return defaultNode(statement, arg); } @override R? visitCompoundSelectPart(CompoundSelectPart e, A arg) { return defaultNode(e, arg); } // General clauses R? visitResultColumn(ResultColumn e, A arg) { return defaultNode(e, arg); } @override R? visitStarResultColumn(StarResultColumn e, A arg) { return visitResultColumn(e, arg); } @override R? visitExpressionResultColumn(ExpressionResultColumn e, A arg) { return visitResultColumn(e, arg); } @override R? visitReturning(Returning e, A arg) { return defaultNode(e, arg); } @override R? visitWithClause(WithClause e, A arg) { return defaultNode(e, arg); } @override R? visitUpsertClause(UpsertClause e, A arg) { return defaultNode(e, arg); } @override R? visitUpsertClauseEntry(UpsertClauseEntry e, A arg) { return defaultNode(e, arg); } @override R? visitDeleteTriggerTarget(DeleteTarget e, A arg) { return defaultTriggerTarget(e, arg); } @override R? visitInsertTriggerTarget(InsertTarget e, A arg) { return defaultTriggerTarget(e, arg); } @override R? visitUpdateTriggerTarget(UpdateTarget e, A arg) { return defaultTriggerTarget(e, arg); } R? defaultTriggerTarget(TriggerTarget e, A arg) { return defaultNode(e, arg); } @override R? visitDoNothing(DoNothing e, A arg) { return defaultUpsertAction(e, arg); } @override R? visitDoUpdate(DoUpdate e, A arg) { return defaultUpsertAction(e, arg); } R? defaultUpsertAction(UpsertAction e, A arg) { return defaultNode(e, arg); } @override R? visitCommonTableExpression(CommonTableExpression e, A arg) { return defaultNode(e, arg); } @override R? visitOrderBy(OrderBy e, A arg) { return defaultNode(e, arg); } @override R? visitOrderingTerm(OrderingTerm e, A arg) { return defaultNode(e, arg); } @override R? visitLimit(Limit e, A arg) { return defaultNode(e, arg); } @override R? visitTableReference(TableReference e, A arg) { return defaultQueryable(e, arg); } @override R? visitSelectStatementAsSource(SelectStatementAsSource e, A arg) { return defaultQueryable(e, arg); } @override R? visitJoinClause(JoinClause e, A arg) { return defaultQueryable(e, arg); } @override R? visitJoinOperator(JoinOperator e, A arg) => defaultNode(e, arg); @override R? visitTableValuedFunction(TableValuedFunction e, A arg) { return defaultQueryable(e, arg); } R? defaultQueryable(Queryable e, A arg) { return defaultNode(e, arg); } @override R? visitJoin(Join e, A arg) { return defaultNode(e, arg); } @override R? visitGroupBy(GroupBy e, A arg) { return defaultNode(e, arg); } @override R? visitSingleColumnSetComponent(SingleColumnSetComponent e, A arg) { return defaultSetComponent(e, arg); } @override R? visitMultiColumnSetComponent(MultiColumnSetComponent e, A arg) { return defaultSetComponent(e, arg); } R? defaultSetComponent(SetComponent e, A arg) { return defaultNode(e, arg); } @override R? visitValuesSource(ValuesSource e, A arg) { return defaultInsertSource(e, arg); } @override R? visitSelectInsertSource(SelectInsertSource e, A arg) { return defaultInsertSource(e, arg); } @override R? visitDefaultValues(DefaultValues e, A arg) { return defaultInsertSource(e, arg); } R? defaultInsertSource(InsertSource e, A arg) { return defaultNode(e, arg); } @override R? visitColumnDefinition(ColumnDefinition e, A arg) { return defaultNode(e, arg); } @override R? visitColumnConstraint(ColumnConstraint e, A arg) { return defaultNode(e, arg); } @override R? visitTableConstraint(TableConstraint e, A arg) { return defaultNode(e, arg); } @override R? visitForeignKeyClause(ForeignKeyClause e, A arg) { return defaultNode(e, arg); } @override R? visitDeferrableClause(DeferrableClause e, A arg) { return defaultNode(e, arg); } @override R? visitWindowDefinition(WindowDefinition e, A arg) { return defaultNode(e, arg); } @override R? visitFrameSpec(FrameSpec e, A arg) { return defaultNode(e, arg); } @override R? visitIndexedColumn(IndexedColumn e, A arg) { return defaultNode(e, arg); } @override R? visitBlock(Block e, A arg) { return defaultNode(e, arg); } @override R? visitSemicolonSeparatedStatements(SemicolonSeparatedStatements e, A arg) { return defaultNode(e, arg); } @override R? visitBeginTransaction(BeginTransactionStatement e, A arg) { return visitStatement(e, arg); } @override R? visitCommitStatement(CommitStatement e, A arg) { return visitStatement(e, arg); } @override R? visitDriftSpecificNode(DriftSpecificNode e, A arg) { return defaultNode(e, arg); } // Expressions @override R? visitCastExpression(CastExpression e, A arg) { return visitExpression(e, arg); } @override R? visitBinaryExpression(BinaryExpression e, A arg) { return visitExpression(e, arg); } @override R? visitCollateExpression(CollateExpression e, A arg) { return visitUnaryExpression(e, arg); } @override R? visitUnaryExpression(UnaryExpression e, A arg) { return visitExpression(e, arg); } @override R? visitStringComparison(StringComparisonExpression e, A arg) { return visitExpression(e, arg); } @override R? visitIsExpression(IsExpression e, A arg) { return visitExpression(e, arg); } @override R? visitIsNullExpression(IsNullExpression e, A arg) { return visitExpression(e, arg); } @override R? visitBetweenExpression(BetweenExpression e, A arg) { return visitExpression(e, arg); } R? defaultLiteral(Literal e, A arg) { return visitExpression(e, arg); } @override R? visitNullLiteral(NullLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitNumericLiteral(NumericLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitBooleanLiteral(BooleanLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitStringLiteral(StringLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitTimeConstantLiteral(TimeConstantLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitReference(Reference e, A arg) { return visitExpression(e, arg); } @override R? visitFunction(FunctionExpression e, A arg) { return visitExpressionInvocation(e, arg); } R? visitFunctionParameters(FunctionParameters e, A arg) { return defaultNode(e, arg); } @override R? visitStarFunctionParameter(StarFunctionParameter e, A arg) { return visitFunctionParameters(e, arg); } @override R? visitExpressionFunctionParameters(ExprFunctionParameters e, A arg) { return visitFunctionParameters(e, arg); } @override R? visitAggregateFunctionInvocation(AggregateFunctionInvocation e, A arg) { return visitExpressionInvocation(e, arg); } @override R? visitWindowFunctionInvocation(WindowFunctionInvocation e, A arg) { return visitAggregateFunctionInvocation(e, arg); } @override R? visitSubQuery(SubQuery e, A arg) { return visitExpression(e, arg); } @override R? visitExists(ExistsExpression e, A arg) { return visitExpression(e, arg); } @override R? visitCaseExpression(CaseExpression e, A arg) { return visitExpression(e, arg); } @override R? visitWhen(WhenComponent e, A arg) { return defaultNode(e, arg); } @override R? visitTuple(Tuple e, A arg) { return visitExpression(e, arg); } @override R? visitParentheses(Parentheses e, A arg) { return visitExpression(e, arg); } @override R? visitInExpression(InExpression e, A arg) { return visitExpression(e, arg); } @override R? visitRaiseExpression(RaiseExpression e, A arg) { return visitExpression(e, arg); } @override R? visitNumberedVariable(NumberedVariable e, A arg) { return visitVariable(e, arg); } @override R? visitNamedVariable(ColonNamedVariable e, A arg) { return visitVariable(e, arg); } R? visitVariable(Variable e, A arg) { return visitExpression(e, arg); } R? visitExpressionInvocation(ExpressionInvocation e, A arg) { return visitInvocation(e, arg); } R? visitInvocation(SqlInvocation e, A arg) { return defaultNode(e, arg); } R? visitExpression(Expression e, A arg) { return defaultNode(e, arg); } R? defaultNode(AstNode e, A arg) { return visitChildren(e, arg); } } class Transformer extends RecursiveVisitor { @override AstNode defaultNode(AstNode e, A arg) => e..transformChildren(this, arg); } extension VisitExtension on AstVisitor { /// Visits the node [e] by calling [AstNode.accept]. R visit(AstNode e, A arg) => e.accept(this, arg); /// Visits the node [e] if it's not null. Otherwise, do nothing. R? visitNullable(AstNode? e, A arg) => e?.accept(this, arg); } extension VisitChildrenExtension on AstVisitor { /// Visits all children of the node [e], in the order of [AstNode.childNodes]. R? visitChildren(AstNode e, A arg) { return visitList(e.childNodes, arg); } /// Visits all [nodes] in sequence. R? visitList(Iterable nodes, A arg) { for (final node in nodes) { node.accept(this, arg); } return null; } /// Visits all children of [node], except for [skip]. void visitExcept(AstNode node, AstNode? skip, A arg) { for (final child in node.childNodes) { if (child != skip) { visit(child, arg); } } } } extension TransformerUtils on Transformer { AstNode? transform(AstNode e, A arg) => visit(e, arg); T transformChild(T child, AstNode parent, A arg) { final transformed = transform(child, arg)!..parent = parent; return transformed as T; } T? transformNullableChild( T? child, AstNode parent, A arg, ) { if (child == null) return null; final transformed = transform(child, arg); transformed?.parent = parent; return transformed as T; } List transformChildren( List children, AstNode parent, A arg) { final newChildren = []; for (final child in children) { // ignore: unnecessary_cast, it's a frontend bug in Dart 2.12 final transformed = transform(child as AstNode, arg) as T?; if (transformed != null) { newChildren.add(transformed..parent = parent); } } return newChildren; } } lib/src/ast/expressions 755 0 0 0 0 12732 5ustar0 pubpublib/src/ast/expressions/simple.dart 644 0 0 14153 14623415614 15567 0ustar0 pubpubpart of '../ast.dart'; class UnaryExpression extends Expression { final Token operator; Expression inner; UnaryExpression(this.operator, this.inner); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUnaryExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { inner = transformer.transformChild(inner, this, arg); } @override Iterable get childNodes => [inner]; } class CollateExpression extends UnaryExpression { final Token collateFunction; String get collation => collateFunction.lexeme; CollateExpression( {required Token operator, required Expression inner, required this.collateFunction}) : super(operator, inner); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCollateExpression(this, arg); } } class BinaryExpression extends Expression { final Token operator; Expression left; Expression right; BinaryExpression(this.left, this.operator, this.right); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBinaryExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); } @override Iterable get childNodes => [left, right]; } /// A like, glob, match or regexp expression. class StringComparisonExpression extends Expression { final bool not; final Token operator; Expression left; Expression right; Expression? escape; StringComparisonExpression( {this.not = false, required this.left, required this.operator, required this.right, this.escape}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitStringComparison(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); escape = transformer.transformNullableChild(escape, this, arg); } @override Iterable get childNodes => [left, right, if (escape != null) escape!]; } /// `(NOT)? $left IS $right` or /// `$left IS (NOT)? DISTINCT FROM $right` class IsExpression extends Expression { final bool negated; bool distinctFromSyntax; Token? $is, distinct, from; Expression left; Expression right; IsExpression(this.negated, this.left, this.right, {this.distinctFromSyntax = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIsExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); } @override Iterable get childNodes => [left, right]; } class IsNullExpression extends Expression { Expression operand; /// When true, this is a `NOT NULL` expression. final bool negated; IsNullExpression(this.operand, [this.negated = false]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIsNullExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { operand = transformer.transformChild(operand, this, arg); } @override Iterable get childNodes => [operand]; } /// `$check BETWEEN $lower AND $upper` class BetweenExpression extends Expression { final bool not; Expression check; Expression lower; Expression upper; BetweenExpression( {this.not = false, required this.check, required this.lower, required this.upper}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBetweenExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { check = transformer.transformChild(check, this, arg); lower = transformer.transformChild(lower, this, arg); upper = transformer.transformChild(upper, this, arg); } @override List get childNodes => [check, lower, upper]; } /// `$left$ IN $inside`. class InExpression extends Expression { final bool not; Expression left; /// The right-hand part: Contains the set of values [left] will be tested /// against. From the sqlite grammar, we support [Tuple] and a [SubQuery]. /// We also support a [Variable] as syntax sugar - it will be expanded into a /// tuple of variables at runtime. InExpressionTarget inside; InExpression({this.not = false, required this.left, required this.inside}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInExpression(this, arg); } @override List get childNodes => [left, inside]; @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); inside = transformer.transformChild(inside, this, arg); } } /// Possible values for the right-hand side of an [InExpression]. /// /// Valid subclasses are: /// - [Tuple], to check whether the LHS is equal to any of the elements in the /// tuple. /// - [SubQuery], to check whether the LHS is equal to any of the rows returned /// by the subquery. /// - [TableReference] and [TableValuedFunction], a short-hand for [SubQuery]s /// if the table or function only return one column. /// - [Variable] (only if drift extensions are enabled), drift's generator /// turns this into a tuple of variables at runtime. abstract class InExpressionTarget implements AstNode {} class Parentheses extends Expression { Token? openingLeft; Token? closingRight; Expression expression; Parentheses(this.expression); @override R accept(AstVisitor visitor, A arg) { return visitor.visitParentheses(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } lib/src/ast/expressions/raise.dart 644 0 0 1313 14345646642 15363 0ustar0 pubpubimport '../node.dart'; import '../visitor.dart'; import 'expressions.dart'; enum RaiseKind { ignore, rollback, abort, fail, } class RaiseExpression extends Expression { final RaiseKind raiseKind; /// The user-defined error message for this `RAISE` expression. /// /// This will be non-null if [raiseKind] is not [RaiseKind.ignore]. final String? errorMessage; RaiseExpression(this.raiseKind, [this.errorMessage]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitRaiseExpression(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/expressions/case.dart 644 0 0 2333 14345646642 15176 0ustar0 pubpubpart of '../ast.dart'; class CaseExpression extends Expression { Expression? base; List whens; Expression? elseExpr; CaseExpression({this.base, required this.whens, this.elseExpr}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCaseExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { base = transformer.transformNullableChild(base, this, arg); whens = transformer.transformChildren(whens, this, arg); elseExpr = transformer.transformNullableChild(elseExpr, this, arg); } @override Iterable get childNodes => [if (base != null) base!, ...whens, if (elseExpr != null) elseExpr!]; } class WhenComponent extends AstNode { Expression when; Expression then; WhenComponent({required this.when, required this.then}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWhen(this, arg); } @override void transformChildren(Transformer transformer, A arg) { when = transformer.transformChild(when, this, arg); then = transformer.transformChild(then, this, arg); } @override Iterable get childNodes => [when, then]; } lib/src/ast/expressions/function.dart 644 0 0 6073 14711507160 16101 0ustar0 pubpubpart of '../ast.dart'; /// Interface for function calls. /// /// Functions that resolve to an [Expression] are subclasses of /// [ExpressionInvocation], like [FunctionExpression] or /// [AggregateFunctionInvocation]. There are invocations that don't resolve to /// an expression, notably [TableValuedFunction]s. abstract class SqlInvocation implements AstNode { /// The name of the function being called String get name; Token? nameToken; FunctionParameters get parameters; } /// Interface for [SqlInvocation]s that are also expressions. abstract class ExpressionInvocation implements SqlInvocation, Expression { /// Whether this function call is to an aggregate function, meaning that it /// will combine multiple rows from the input relation into one. /// /// While [AggregateFunctionInvocation]s are always aggregates due to their /// syntax, regular function expressions to known aggregate functions are /// considered as well. bool get isAggregate; } class FunctionExpression extends Expression with ReferenceOwner implements ExpressionInvocation { @override final String name; @override FunctionParameters parameters; @override Token? nameToken; FunctionExpression({required this.name, required this.parameters}); @override bool get isAggregate => const { 'avg', 'count', 'group_concat', 'string_agg', 'max', 'min', 'sum', 'total', 'json_group_array', 'jsonb_group_array', 'json_group_object', 'jsonb_group_object', }.contains(name.toLowerCase()); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFunction(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); } @override Iterable get childNodes { return [parameters]; } } /// Marker interface for anything that can be inside the parentheses after a /// function name. abstract class FunctionParameters extends AstNode {} /// Using a star as a function parameter. For instance: "COUNT(*)". class StarFunctionParameter extends FunctionParameters { StarFunctionParameter(); Token? starToken; @override R accept(AstVisitor visitor, A arg) { return visitor.visitStarFunctionParameter(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const Iterable.empty(); } class ExprFunctionParameters extends FunctionParameters { final bool distinct; Token? distinctKeyword; List parameters; ExprFunctionParameters({this.parameters = const [], this.distinct = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExpressionFunctionParameters(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChildren(parameters, this, arg); } @override List get childNodes => parameters; } lib/src/ast/expressions/reference.dart 644 0 0 3200 14345646642 16213 0ustar0 pubpubpart of '../ast.dart'; /// Expression that refers to an individual expression declared somewhere else /// in the table. /// /// For instance, in "SELECT table.c FROM table", the "table.c" is a reference /// that refers to the column "c" in a table "table". In "SELECT COUNT(*) AS c, /// 2 * c AS d FROM table", the "c" after the "2 *" is a reference that refers /// to the expression "COUNT(*)". class Reference extends Expression with ReferenceOwner { /// An optional schema name. /// /// When this is non-null, [entityName] will not be null either. final String? schemaName; /// Entity can be either a table or a view. final String? entityName; final String columnName; /// The resolved result set from the [entityName]. ResultSetAvailableInStatement? resultEntity; Column? get resolvedColumn => resolved as Column?; Reference({this.entityName, this.schemaName, required this.columnName}) : assert( entityName != null || schemaName == null, 'When setting a schemaName, entityName must not be null either.', ); @override R accept(AstVisitor visitor, A arg) { return visitor.visitReference(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; @override String toString() { final result = StringBuffer(); if (schemaName != null) { result ..write(schemaName) ..write('.'); } if (entityName != null) { result ..write(entityName) ..write('.'); } result.write(columnName); return result.toString(); } } lib/src/ast/expressions/expressions.dart 644 0 0 200 14345646642 16614 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../node.dart'; abstract class Expression extends AstNode implements Typeable {} lib/src/ast/expressions/subquery.dart 644 0 0 2006 14623415614 16127 0ustar0 pubpubpart of '../ast.dart'; /// A subquery, which is an expression. It is expected that the inner query /// only returns one column and one row. class SubQuery extends Expression implements InExpressionTarget { BaseSelectStatement select; SubQuery({required this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSubQuery(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override Iterable get childNodes => [select]; } class ExistsExpression extends Expression { BaseSelectStatement select; ExistsExpression({required this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExists(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override Iterable get childNodes => [select]; } lib/src/ast/expressions/cast.dart 644 0 0 1024 14345646642 15211 0ustar0 pubpubpart of '../ast.dart'; /// A `CAST( AS )` expression. class CastExpression extends Expression { Expression operand; final String typeName; CastExpression(this.operand, this.typeName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCastExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { operand = transformer.transformChild(operand, this, arg); } @override Iterable get childNodes => [operand]; } lib/src/ast/expressions/variables.dart 644 0 0 2177 14623415614 16231 0ustar0 pubpubpart of '../ast.dart'; abstract class Variable extends Expression implements InExpressionTarget { int? resolvedIndex; } /// A "?" or "?123" variable placeholder class NumberedVariable extends Expression implements Variable { QuestionMarkVariableToken? token; int? explicitIndex; @override int? resolvedIndex; NumberedVariable(this.explicitIndex) : resolvedIndex = explicitIndex; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumberedVariable(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; } class ColonNamedVariable extends Expression implements Variable { final String name; @override int? resolvedIndex; ColonNamedVariable.synthetic(this.name); ColonNamedVariable(ColonVariableToken token) : name = token.name; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNamedVariable(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => []; } lib/src/ast/expressions/aggregate.dart 644 0 0 17261 14711507160 16223 0ustar0 pubpubpart of '../ast.dart'; class AggregateFunctionInvocation extends Expression implements ExpressionInvocation, ReferenceOwner { final IdentifierToken function; @override String get name => function.identifier; @override Token? nameToken; @override FunctionParameters parameters; OrderByBase? orderBy; Expression? filter; @override Referencable? resolved; AggregateFunctionInvocation({ required this.function, required this.parameters, this.orderBy, this.filter, }) : nameToken = function; @override bool get isAggregate => true; @override R accept(AstVisitor visitor, A arg) { return visitor.visitAggregateFunctionInvocation(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); orderBy = transformer.transformNullableChild(orderBy, this, arg); filter = transformer.transformNullableChild(filter, this, arg); } @override Iterable get childNodes { return [parameters, if (filter != null) filter!]; } } class WindowFunctionInvocation extends AggregateFunctionInvocation { WindowDefinition? get over { if (windowDefinition != null) return windowDefinition; return (resolved as NamedWindowDeclaration?)?.definition; } /// The window definition as declared in the `OVER` clause in sql. If this /// aggregate expression didn't declare a window (e.g. it instead uses a /// window via a name declared in the surrounding `SELECT` statement), we're /// this field will be null. Either [windowDefinition] or [windowName] are /// null. The resolved [WindowDefinition] is available in [over] in either /// case. WindowDefinition? windowDefinition; /// An aggregate expression can be written as `OVER ` instead of /// declaring its own [windowDefinition]. Either [windowDefinition] or /// [windowName] are null. The resolved [WindowDefinition] is available in /// [over] in either case. final String? windowName; WindowFunctionInvocation( {required super.function, required super.parameters, super.orderBy, super.filter, this.windowDefinition, this.windowName}) // one of window definition or name must be null : assert((windowDefinition == null) || (windowName == null)); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWindowFunctionInvocation(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); filter = transformer.transformNullableChild(filter, this, arg); windowDefinition = transformer.transformNullableChild(windowDefinition, this, arg); } @override Iterable get childNodes { return [ parameters, if (filter != null) filter!, if (windowDefinition != null) windowDefinition!, ]; } } /// A window declaration that appears in a `SELECT` statement like /// `WINDOW AS `. It can be referenced from an /// [AggregateFunctionInvocation] if it uses the same name. class NamedWindowDeclaration with Referencable { // todo: Should be an ast node final String name; final WindowDefinition definition; NamedWindowDeclaration(this.name, this.definition); } class WindowDefinition extends AstNode { final String? baseWindowName; List partitionBy; OrderByBase? orderBy; FrameSpec frameSpec; WindowDefinition( {this.baseWindowName, this.partitionBy = const [], this.orderBy, required this.frameSpec}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWindowDefinition(this, arg); } @override void transformChildren(Transformer transformer, A arg) { partitionBy = transformer.transformChildren(partitionBy, this, arg); orderBy = transformer.transformNullableChild(orderBy, this, arg); frameSpec = transformer.transformChild(frameSpec, this, arg); } @override Iterable get childNodes => [...partitionBy, if (orderBy != null) orderBy!, frameSpec]; } class FrameSpec extends AstNode { final FrameType? type; final ExcludeMode? excludeMode; FrameBoundary start; FrameBoundary end; FrameSpec({ this.type = FrameType.range, FrameBoundary? start, FrameBoundary? end, this.excludeMode = ExcludeMode.noOthers, }) : start = start ?? FrameBoundary.unboundedPreceding(), end = end ?? FrameBoundary.currentRow(); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFrameSpec(this, arg); } @override void transformChildren(Transformer transformer, A arg) { if (start.isExpressionOffset) { start.offset = transformer.transformChild(start.offset!, this, arg); } if (end.isExpressionOffset) { end.offset = transformer.transformChild(end.offset!, this, arg); } } @override Iterable get childNodes => [ if (start.isExpressionOffset) start.offset!, if (end.isExpressionOffset) end.offset!, ]; } /// Defines how a [FrameBoundary] count rows or groups. See /// https://www.sqlite.org/windowfunctions.html#frame_type for details. enum FrameType { rows, groups, range } /// Defines if rows are omitted inside a [FrameBoundary]. enum ExcludeMode { /// default, no rows are excluded from the window frame noOthers, /// the current row is excluded from the window frame currentRow, /// The row and and its peers (rows considered to be equal to the ORDER BY /// clause) are excluded group, /// Peers of the row are excluded (see [group]), but not the row itself. ties, } enum _BoundaryType { currentRow, exprOffset, unboundedOffset, } /// Defines how many rows before or after a current row should be included in /// a window. class FrameBoundary { final _BoundaryType _type; /// The (integer) expression that specifies the amount of rows to include /// before or after the row being processed. Expression? offset; /// Whether this boundary refers to a row before the current row. final bool preceding; bool get following => !preceding; /// Whether this boundary is a ` PRECEDING` or ` FOLLOWING` /// boundary. bool get isExpressionOffset => _type == _BoundaryType.exprOffset; /// Whether this boundary is a `UNBOUNDED PRECEDING` or `UNBOUNDED FOLLOWING`. bool get isUnbounded => _type == _BoundaryType.unboundedOffset; /// Whether this boundary only refers to the current row. bool get isCurrentRow => _type == _BoundaryType.currentRow; FrameBoundary._(this._type, this.preceding, {this.offset}); FrameBoundary.unboundedPreceding() : this._(_BoundaryType.unboundedOffset, true); FrameBoundary.unboundedFollowing() : this._(_BoundaryType.unboundedOffset, false); FrameBoundary.currentRow() : this._(_BoundaryType.currentRow, false); FrameBoundary.preceding(Expression amount) : this._(_BoundaryType.exprOffset, true, offset: amount); FrameBoundary.following(Expression amount) : this._(_BoundaryType.exprOffset, false, offset: amount); @override int get hashCode { return (preceding ? 2 : 3) * (5 * offset.hashCode + _type.hashCode); } @override bool operator ==(Object other) { if (identical(this, other)) return true; if (other.runtimeType != runtimeType) return false; // lint bug: https://github.com/dart-lang/linter/issues/1397 final typedOther = other as FrameBoundary; // ignore: test_types_in_equals return typedOther._type == _type && (typedOther.offset == null && offset == null || typedOther.offset!.contentEquals(offset!)) && typedOther.preceding == preceding; } } lib/src/ast/expressions/literals.dart 644 0 0 3364 14354621567 16106 0ustar0 pubpubpart of '../ast.dart'; // https://www.sqlite.org/syntax/literal-value.html @optionalTypeArgs abstract class Literal extends Expression { Token? token; T get value; Literal(); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} @override String toString() { return 'Literal with value $value'; } } class NullLiteral extends Literal { @override Null get value => null; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNullLiteral(this, arg); } } class NumericLiteral extends Literal { @override final num value; bool get isInt => value is int; NumericLiteral(this.value); @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumericLiteral(this, arg); } } class BooleanLiteral extends Literal { @override final bool value; BooleanLiteral(this.value); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBooleanLiteral(this, arg); } } class StringLiteral extends Literal { @override final String value; final bool isBinary; StringLiteral(this.value, {this.isBinary = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitStringLiteral(this, arg); } } enum TimeConstantKind { currentTime, currentDate, currentTimestamp } class TimeConstantLiteral extends Literal { final TimeConstantKind kind; TimeConstantLiteral(this.kind); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTimeConstantLiteral(this, arg); } @override dynamic get value => throw UnimplementedError('TimeConstantLiteral.value'); } lib/src/ast/schema 755 0 0 0 0 11610 5ustar0 pubpublib/src/ast/schema/table_definition.dart 644 0 0 7566 14656673450 16457 0ustar0 pubpubpart of '../ast.dart'; enum ReferenceAction { setNull, setDefault, cascade, restrict, noAction } class ForeignKeyClause extends AstNode { TableReference foreignTable; List columnNames; final ReferenceAction? onDelete; final ReferenceAction? onUpdate; DeferrableClause? deferrable; ForeignKeyClause({ required this.foreignTable, required this.columnNames, this.onDelete, this.onUpdate, this.deferrable, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitForeignKeyClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { foreignTable = transformer.transformChild(foreignTable, this, arg); columnNames = transformer.transformChildren(columnNames, this, arg); deferrable = transformer.transformChild(deferrable!, this, arg); } @override Iterable get childNodes => [ foreignTable, ...columnNames, if (deferrable != null) deferrable!, ]; InitialDeferrableMode get effectiveDeferrableMode { return deferrable?.effectiveInitialMode ?? InitialDeferrableMode.immediate; } } enum InitialDeferrableMode { deferred, immediate, } class DeferrableClause extends AstNode { final bool not; final InitialDeferrableMode? declaredInitially; DeferrableClause(this.not, this.declaredInitially); InitialDeferrableMode? get effectiveInitialMode { if (not || declaredInitially == null) { return InitialDeferrableMode.immediate; } return declaredInitially; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeferrableClause(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } abstract class TableConstraint extends AstNode { final String? name; Token? nameToken; TableConstraint(this.name); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableConstraint(this, arg); } bool constraintEquals(covariant TableConstraint other); } class KeyClause extends TableConstraint { final bool isPrimaryKey; List columns; final ConflictClause? onConflict; bool get isUnique => !isPrimaryKey; @Deprecated('Use columns instead') List get indexedColumns { return [ for (final column in columns) if (column.expression is Reference) column.expression as Reference ]; } KeyClause(super.name, {required this.isPrimaryKey, required this.columns, this.onConflict}); @override bool constraintEquals(KeyClause other) { return other.isPrimaryKey == isPrimaryKey && other.onConflict == onConflict; } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); } @override Iterable get childNodes => columns; } class CheckTable extends TableConstraint { Expression expression; CheckTable(super.name, this.expression); @override bool constraintEquals(CheckTable other) => true; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } class ForeignKeyTableConstraint extends TableConstraint { List columns; ForeignKeyClause clause; ForeignKeyTableConstraint(super.name, {required this.columns, required this.clause}); @override bool constraintEquals(ForeignKeyTableConstraint other) => true; @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); clause = transformer.transformChild(clause, this, arg); } @override Iterable get childNodes => [...columns, clause]; } lib/src/ast/schema/column_definition.dart 644 0 0 16007 14612235271 16656 0ustar0 pubpubpart of '../ast.dart'; /// https://www.sqlite.org/syntax/column-def.html class ColumnDefinition extends AstNode { final String columnName; final String? typeName; List constraints; /// The tokens there were involved in defining the type of this column. List? typeNames; Token? nameToken; ColumnDefinition( {required this.columnName, required this.typeName, this.constraints = const []}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitColumnDefinition(this, arg); } @override void transformChildren(Transformer transformer, A arg) { constraints = transformer.transformChildren(constraints, this, arg); } @override Iterable get childNodes => constraints; bool get isNonNullable => findConstraint() != null; /// Finds a constraint of type [T], or null, if none is set. T? findConstraint() { final typedConstraints = constraints.whereType().iterator; if (typedConstraints.moveNext()) { return typedConstraints.current; } return null; } } /// https://www.sqlite.org/syntax/column-constraint.html abstract class ColumnConstraint extends AstNode { final String? name; ColumnConstraint(this.name); @override R accept(AstVisitor visitor, A arg) { return visitor.visitColumnConstraint(this, arg); } T? when({ T Function(NotNull)? notNull, T Function(NullColumnConstraint)? nullable, T Function(PrimaryKeyColumn)? primaryKey, T Function(UniqueColumn)? unique, T Function(CheckColumn)? check, T Function(Default)? isDefault, T Function(CollateConstraint)? collate, T Function(ForeignKeyColumnConstraint)? foreignKey, T Function(MappedBy)? mappedBy, T Function(GeneratedAs)? generatedAs, }) { if (this is NotNull) { return notNull?.call(this as NotNull); } else if (this is NullColumnConstraint) { return nullable?.call(this as NullColumnConstraint); } else if (this is PrimaryKeyColumn) { return primaryKey?.call(this as PrimaryKeyColumn); } else if (this is UniqueColumn) { return unique?.call(this as UniqueColumn); } else if (this is CheckColumn) { return check?.call(this as CheckColumn); } else if (this is Default) { return isDefault?.call(this as Default); } else if (this is CollateConstraint) { return collate?.call(this as CollateConstraint); } else if (this is ForeignKeyColumnConstraint) { return foreignKey?.call(this as ForeignKeyColumnConstraint); } else if (this is MappedBy) { return mappedBy?.call(this as MappedBy); } else if (this is GeneratedAs) { return generatedAs?.call(this as GeneratedAs); } else { throw Exception('Did not expect $runtimeType as a ColumnConstraint'); } } } enum ConflictClause { rollback, abort, fail, ignore, replace } class NullColumnConstraint extends ColumnConstraint { /// The `NULL` token forming this constraint. Token? $null; NullColumnConstraint(super.name, {this.$null}); @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } class NotNull extends ColumnConstraint { final ConflictClause? onConflict; Token? not; Token? $null; NotNull(super.name, {this.onConflict}); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } class PrimaryKeyColumn extends ColumnConstraint { final bool autoIncrement; final ConflictClause? onConflict; final OrderingMode? mode; PrimaryKeyColumn(super.name, {this.autoIncrement = false, this.mode, this.onConflict}); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} } class UniqueColumn extends ColumnConstraint { final ConflictClause? onConflict; UniqueColumn(super.name, this.onConflict); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} } class CheckColumn extends ColumnConstraint { Expression expression; CheckColumn(super.name, this.expression); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } class Default extends ColumnConstraint { Expression expression; Default(super.name, this.expression); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } class CollateConstraint extends ColumnConstraint { final String collation; CollateConstraint(super.name, this.collation); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } class ForeignKeyColumnConstraint extends ColumnConstraint { ForeignKeyClause clause; ForeignKeyColumnConstraint(super.name, this.clause); @override Iterable get childNodes => [clause]; @override void transformChildren(Transformer transformer, A arg) { clause = transformer.transformChild(clause, this, arg); } } class GeneratedAs extends ColumnConstraint { Expression expression; bool stored; GeneratedAs(this.expression, {this.stored = false, String? name}) : super(name); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } /// A `MAPPED BY` constraint, which is only parsed for drift files. It can be /// used to declare a type converter for this column. class MappedBy extends ColumnConstraint { /// The Dart expression creating the type converter we use to map this token. final InlineDartToken mapper; MappedBy(super.name, this.mapper); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } /// A `JSON KEY xyz` constraint, which is only parsed for drift files. class JsonKey extends ColumnConstraint { Token? json; Token? key; IdentifierToken jsonNameToken; @override final Iterable childNodes = const []; String get jsonKey => jsonNameToken.identifier; JsonKey(super.name, this.jsonNameToken); @override void transformChildren(Transformer transformer, A arg) {} } /// A `AS xyz` constraint, which is only parsed for drift files. class DriftDartName extends ColumnConstraint { Token? as; IdentifierToken identifier; @override final Iterable childNodes = const []; String get dartName => identifier.identifier; DriftDartName(super.name, this.identifier); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/ast.dart 644 0 0 3334 14345646642 12472 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'drift/inline_dart.dart'; import 'expressions/expressions.dart'; import 'node.dart'; import 'statements/create_index.dart'; import 'statements/select.dart'; import 'visitor.dart'; export 'clauses/returning.dart'; export 'clauses/upsert.dart'; export 'drift/declared_statement.dart'; export 'drift/drift_file.dart'; export 'drift/import_statement.dart'; export 'drift/inline_dart.dart'; export 'drift/nested_query_column.dart'; export 'drift/nested_star_result_column.dart'; export 'expressions/expressions.dart'; export 'expressions/raise.dart'; export 'node.dart'; export 'statements/block.dart'; export 'statements/create_index.dart'; export 'statements/create_table.dart'; export 'statements/create_trigger.dart'; export 'statements/create_view.dart'; export 'statements/delete.dart'; export 'statements/insert.dart'; export 'statements/invalid.dart'; export 'statements/select.dart'; export 'statements/statement.dart'; export 'statements/transaction.dart'; export 'statements/update.dart'; export 'visitor.dart'; // todo: Split up this mega-library part 'clauses/limit.dart'; part 'clauses/ordering.dart'; part 'clauses/with.dart'; part 'common/queryables.dart'; part 'common/renamable.dart'; part 'common/tuple.dart'; part 'expressions/aggregate.dart'; part 'expressions/case.dart'; part 'expressions/cast.dart'; part 'expressions/function.dart'; part 'expressions/literals.dart'; part 'expressions/reference.dart'; part 'expressions/simple.dart'; part 'expressions/subquery.dart'; part 'expressions/variables.dart'; part 'schema/column_definition.dart'; part 'schema/table_definition.dart'; lib/src/ast/statements 755 0 0 0 0 12537 5ustar0 pubpublib/src/ast/statements/update.dart 644 0 0 6671 14612235271 15350 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import enum FailureMode { rollback, abort, replace, fail, ignore, } const Map _tokensToMode = { TokenType.rollback: FailureMode.rollback, TokenType.abort: FailureMode.abort, TokenType.replace: FailureMode.replace, TokenType.fail: FailureMode.fail, TokenType.ignore: FailureMode.ignore, }; class UpdateStatement extends CrudStatement implements StatementWithWhere, HasPrimarySource, HasFrom, StatementReturningColumns { final FailureMode? or; @override TableReference table; List set; @override Queryable? from; @override Expression? where; @override Returning? returning; @override ResultSet? returnedResultSet; UpdateStatement({ WithClause? withClause, this.or, required this.table, required this.set, this.from, this.where, this.returning, }) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpdateStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); table = transformer.transformChild(table, this, arg); set = transformer.transformChildren(set, this, arg); from = transformer.transformNullableChild(from, this, arg); where = transformer.transformChild(where!, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, table, ...set, if (from != null) from!, if (where != null) where!, if (returning != null) returning!, ]; static FailureMode? failureModeFromToken(TokenType token) { return _tokensToMode[token]; } } abstract class SetComponent extends AstNode { List get columns; } class SingleColumnSetComponent extends SetComponent { Reference column; Expression expression; @override List get columns => [column]; SingleColumnSetComponent({required this.column, required this.expression}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSingleColumnSetComponent(this, arg); } @override void transformChildren(Transformer transformer, A arg) { column = transformer.transformChild(column, this, arg); expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [column, expression]; } class MultiColumnSetComponent extends SetComponent { @override List columns; // Will be either Tuple or SubQuery Expression rowValue; List? get resolvedTargetColumns { if (columns.isEmpty) return null; return columns.map((c) => c.resolvedColumn).toList(); } MultiColumnSetComponent({required this.columns, required this.rowValue}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitMultiColumnSetComponent(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); rowValue = transformer.transformChild(rowValue, this, arg); } @override Iterable get childNodes => [...columns, rowValue]; } lib/src/ast/statements/block.dart 644 0 0 1152 14345646642 15160 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../visitor.dart'; import 'statement.dart'; /// BLOCK = 'BEGIN' < CRUD-STATEMENT ';' > 'END' class Block extends AstNode { Token? begin; Token? end; List statements; Block(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBlock(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statements = transformer.transformChildren(statements, this, arg); } @override Iterable get childNodes => statements; } lib/src/ast/statements/create_trigger.dart 644 0 0 6546 14711507160 17054 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import /// A "CREATE TRIGGER" statement, see https://sqlite.org/lang_createtrigger.html class CreateTriggerStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String triggerName; IdentifierToken? triggerNameToken; final TriggerMode mode; TriggerTarget target; TableReference onTable; Expression? when; Block action; CreateTriggerStatement( {this.ifNotExists = false, required this.triggerName, required this.mode, required this.target, required this.onTable, this.when, required this.action}); @override String get createdName => triggerName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateTriggerStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { onTable = transformer.transformChild(onTable, this, arg); when = transformer.transformNullableChild(when, this, arg); action = transformer.transformChild(action, this, arg); target = transformer.transformChild(target, this, arg); } @override Iterable get childNodes => [ target, onTable, if (when != null) when!, action, ]; } enum TriggerMode { before, after, insteadOf; // https://www.sqlite.org/lang_createtrigger.html#instead_of_triggers bool get isSupportedOnViews => this == insteadOf; bool get isSupportedOnTables => this != insteadOf; } abstract class TriggerTarget extends AstNode { @override int get hashCode => runtimeType.hashCode; @override bool operator ==(Object other) => other.runtimeType == runtimeType; @override Iterable get childNodes => const Iterable.empty(); /// Whether this target introduces the "new" table reference in the sub-scope /// of the create trigger statement. bool get introducesNew; /// Whether this target introduces the "old" table reference in the sub-scope /// of the create trigger statement. bool get introducesOld; } class DeleteTarget extends TriggerTarget { Token? deleteToken; @override bool get introducesNew => false; @override bool get introducesOld => true; @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeleteTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } class InsertTarget extends TriggerTarget { Token? insertToken; @override bool get introducesNew => true; @override bool get introducesOld => false; @override R accept(AstVisitor visitor, A arg) { return visitor.visitInsertTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } class UpdateTarget extends TriggerTarget { Token? updateToken; List columnNames; UpdateTarget(this.columnNames); @override bool get introducesNew => true; @override bool get introducesOld => true; @override Iterable get childNodes => columnNames; @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpdateTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columnNames = transformer.transformChildren(columnNames, this, arg); } } lib/src/ast/statements/create_index.dart 644 0 0 3720 14345646642 16523 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import class CreateIndexStatement extends Statement implements CreatingStatement, StatementWithWhere { final String indexName; final bool unique; final bool ifNotExists; IdentifierToken? nameToken; TableReference on; List columns; @override Expression? where; CreateIndexStatement( {required this.indexName, this.unique = false, this.ifNotExists = false, required this.on, required this.columns, this.where}); @override String get createdName => indexName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateIndexStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { on = transformer.transformChild(on, this, arg); columns = transformer.transformChildren(columns, this, arg); where = transformer.transformNullableChild(where, this, arg); } @override Iterable get childNodes => [on, ...columns, if (where != null) where!]; } /// Note that this class matches the productions listed at https://www.sqlite.org/syntax/indexed-column.html /// We don't have a special case for `column-name` (those are [Reference]s). /// The `COLLATE` branch is covered by parsing a [CollateExpression] for /// [expression]. class IndexedColumn extends AstNode { /// The expression on which the index should be created. Most commonly a /// [Reference], for simple column names. Expression expression; final OrderingMode? ordering; IndexedColumn(this.expression, [this.ordering]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIndexedColumn(this, arg); } @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } lib/src/ast/statements/transaction.dart 644 0 0 1754 14345646642 16423 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../visitor.dart'; import 'statement.dart'; enum TransactionMode { none, deferred, immediate, exclusive } class BeginTransactionStatement extends Statement { Token? begin, modeToken, transaction; final TransactionMode mode; BeginTransactionStatement([this.mode = TransactionMode.none]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBeginTransaction(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } class CommitStatement extends Statement { Token? commitOrEnd, transaction; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCommitStatement(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/statements/create_table.dart 644 0 0 6556 14345646642 16515 0ustar0 pubpubimport 'package:source_span/source_span.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class TableInducingStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String tableName; /// Drift-specific information about the desired name of a Dart class for this /// table. /// /// This will always be `null` when drift extensions are not enabled. DriftTableName? driftTableName; Token? tableNameToken; TableInducingStatement._(this.ifNotExists, this.tableName, [this.driftTableName]); @override String get createdName => tableName; } /// A "CREATE TABLE" statement, see https://www.sqlite.org/lang_createtable.html /// for the individual components. class CreateTableStatement extends TableInducingStatement { List columns; List tableConstraints; /// Whether this table has been defined with an `WITHOUT ROWID` clause. final bool withoutRowId; /// Whether this table has been defined as `STRICT`. /// /// Strict tables are limited to a few column type names. Columns in strict /// tables may not store other types. final bool isStrict; Token? openingBracket; Token? closingBracket; Token? strict; CreateTableStatement({ bool ifNotExists = false, required String tableName, this.columns = const [], this.tableConstraints = const [], this.withoutRowId = false, this.isStrict = false, DriftTableName? driftTableName, }) : super._(ifNotExists, tableName, driftTableName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateTableStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); tableConstraints = transformer.transformChildren(tableConstraints, this, arg); driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [ ...columns, ...tableConstraints, if (driftTableName != null) driftTableName!, ]; } class CreateVirtualTableStatement extends TableInducingStatement { /// The module that will be invoked when creating the virtual table. final String moduleName; Token? moduleNameToken; /// Arguments passed to the module. Since the specific module is responsible /// for parsing them, the general parser only exposes them as strings with a /// source location. final List arguments; List? _argumentText; List get argumentContent { return _argumentText ??= arguments.map((a) => a.text).toList(); } CreateVirtualTableStatement({ bool ifNotExists = false, required String tableName, required this.moduleName, this.arguments = const [], DriftTableName? driftTableName, }) : super._(ifNotExists, tableName, driftTableName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateVirtualTableStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [if (driftTableName != null) driftTableName!]; } lib/src/ast/statements/statement.dart 644 0 0 5372 14612235271 16067 0ustar0 pubpubimport 'package:meta/meta.dart'; import '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class Statement extends AstNode { Token? semicolon; } /// A list of statements, separated by semicolons. class SemicolonSeparatedStatements extends AstNode { List statements; SemicolonSeparatedStatements(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSemicolonSeparatedStatements(this, arg); } @override Iterable get childNodes => statements; @override void transformChildren(Transformer transformer, A arg) { statements = transformer.transformChildren(statements, this, arg); } } /// A statement that reads from an existing table structure and has an optional /// `WITH` clause. abstract class CrudStatement extends Statement { WithClause? withClause; @internal CrudStatement(this.withClause); } /// Interfaces for statements that have a primary source table on which they /// operate. /// This includes delete, update and insert statements. It also includes the /// common [SelectStatement], but not compound select statements or `VALUES` /// statements. abstract class HasPrimarySource extends Statement { /// The primary table this statement operates on. This is the part after the /// `FROM` for select and delete statements, the part after the `INTO` for /// inserts and the name after the `UPDATE` for updates. Queryable? get table; } /// Interfaces for statements that have a `FROM` clause. /// /// This includes selects and, since recently, updates. abstract class HasFrom extends Statement { /// The table, join clause or subquery appearing in the `FROM` clause. Queryable? get from; } /// Interface for statements that have a primary where clause (select, update, /// delete). abstract class StatementWithWhere extends Statement implements HasWhereClause {} /// Interface for statements that can return columns after writing data. /// /// Columns are returned with a `RETURNING` clause (see [Returning]). After /// analyzing a node, statements with a [returning] clause will have their /// [returnedResultSet] set to the resolved columns. abstract class StatementReturningColumns extends Statement { /// The returning clause of this statement, if there is any. Returning? get returning; /// The result set of the [returning] clause. ResultSet? returnedResultSet; } /// Marker interface for statements that change the table structure. abstract class SchemaStatement extends Statement implements PartOfDriftFile {} /// Marker interface for schema statements that create a schematic entity. abstract class CreatingStatement extends SchemaStatement { String get createdName; } lib/src/ast/statements/insert.dart 644 0 0 6455 14436724364 15404 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart'; // todo: Remove this import enum InsertMode { insert, replace, insertOrReplace, insertOrRollback, insertOrAbort, insertOrFail, insertOrIgnore } class InsertStatement extends CrudStatement implements HasPrimarySource, StatementReturningColumns { final InsertMode mode; @override TableReference table; List targetColumns; InsertSource source; UpsertClause? upsert; @override Returning? returning; @override ResultSet? returnedResultSet; List? get resolvedTargetColumns { if (targetColumns.isNotEmpty) { return targetColumns.map((c) => c.resolvedColumn).toList(); } else { // no columns declared - assume all columns from the table that are not // generated. return table.resultSet?.resolvedColumns ?.where((c) => c is! TableColumn || !c.isGenerated) .toList(); } } InsertStatement({ WithClause? withClause, this.mode = InsertMode.insert, required this.table, required this.targetColumns, required this.source, this.upsert, this.returning, }) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInsertStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); table = transformer.transformChild(table, this, arg); targetColumns = transformer.transformChildren(targetColumns, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, table, ...targetColumns, source, if (upsert != null) upsert!, if (returning != null) returning!, ]; } /// Marker interface for AST nodes that can be used as data sources in insert /// statements. abstract class InsertSource extends AstNode {} /// Uses a list of values for an insert statement (`VALUES (a, b, c)`). class ValuesSource extends InsertSource { List values; ValuesSource(this.values); @override Iterable get childNodes => values; @override R accept(AstVisitor visitor, A arg) { return visitor.visitValuesSource(this, arg); } @override void transformChildren(Transformer transformer, A arg) { values = transformer.transformChildren(values, this, arg); } } /// Inserts the rows returned by [stmt]. class SelectInsertSource extends InsertSource { BaseSelectStatement stmt; SelectInsertSource(this.stmt); @override Iterable get childNodes => [stmt]; @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectInsertSource(this, arg); } @override void transformChildren(Transformer transformer, A arg) { stmt = transformer.transformChild(stmt, this, arg); } } /// Use `DEFAULT VALUES` for an insert statement. class DefaultValues extends InsertSource { @override Iterable get childNodes => const []; @override R accept(AstVisitor visitor, A arg) { return visitor.visitDefaultValues(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/statements/invalid.dart 644 0 0 647 14345646642 15504 0ustar0 pubpubimport '../ast.dart'; /// Used as a top-level substitute when no statement could be parsed otherwise. class InvalidStatement extends Statement { @override R accept(AstVisitor visitor, A arg) { return visitor.visitInvalidStatement(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/statements/delete.dart 644 0 0 2264 14345646642 15335 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart'; // todo: Remove this import class DeleteStatement extends CrudStatement implements StatementWithWhere, StatementReturningColumns, HasPrimarySource { TableReference from; @override Expression? where; @override TableReference get table => from; @override Returning? returning; @override ResultSet? returnedResultSet; DeleteStatement( {WithClause? withClause, required this.from, this.where, this.returning}) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeleteStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); from = transformer.transformChild(from, this, arg); where = transformer.transformNullableChild(where, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, from, if (where != null) where!, if (returning != null) returning!, ]; } lib/src/ast/statements/create_view.dart 644 0 0 2376 14345646642 16374 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import /// A "CREATE VIEW" statement, see https://sqlite.org/lang_createview.html class CreateViewStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String viewName; IdentifierToken? viewNameToken; BaseSelectStatement query; final List? columns; /// Drift-specific information about the desired name of a Dart class for this /// table. /// /// This will always be `null` when drift extensions are not enabled. DriftTableName? driftTableName; CreateViewStatement({ this.ifNotExists = false, required this.viewName, this.columns, required this.query, this.driftTableName, }); @override String get createdName => viewName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateViewStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { query = transformer.transformChild(query, this, arg); driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [query, if (driftTableName != null) driftTableName!]; } lib/src/ast/statements/select.dart 644 0 0 16341 14647230467 15372 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class BaseSelectStatement extends CrudStatement with ResultSet { /// The resolved list of columns returned by this select statements. Not /// available from the parse tree, will be set later by the analyzer. @override List? resolvedColumns; BaseSelectStatement._(super.withClause); } /// Marker interface for classes that are a [BaseSelectStatement] but aren't a /// [CompoundSelectStatement]. abstract class SelectStatementNoCompound implements BaseSelectStatement {} class SelectStatement extends BaseSelectStatement implements StatementWithWhere, SelectStatementNoCompound, HasPrimarySource, HasFrom { final bool distinct; List columns; @override Queryable? from; @override Expression? where; GroupBy? groupBy; final List windowDeclarations; OrderByBase? orderBy; LimitBase? limit; @override Queryable? get table => from; SelectStatement( {WithClause? withClause, this.distinct = false, required this.columns, this.from, this.where, this.groupBy, this.windowDeclarations = const [], this.orderBy, this.limit}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); columns = transformer.transformChildren(columns, this, arg); from = transformer.transformNullableChild(from, this, arg); where = transformer.transformNullableChild(where, this, arg); groupBy = transformer.transformNullableChild(groupBy, this, arg); // transformer.transformChildren(windowDeclarations, this, arg); limit = transformer.transformNullableChild(limit, this, arg); orderBy = transformer.transformNullableChild(orderBy, this, arg); } @override Iterable get childNodes { return [ if (withClause != null) withClause!, ...columns, if (from != null) from!, if (where != null) where!, if (groupBy != null) groupBy!, for (var windowDecl in windowDeclarations) windowDecl.definition, if (limit != null) limit!, if (orderBy != null) orderBy!, ]; } } class CompoundSelectStatement extends BaseSelectStatement { SelectStatementNoCompound base; List additional; // the grammar under https://www.sqlite.org/syntax/compound-select-stmt.html // defines an order by and limit clause on this node, but we parse them as // part of the last compound select statement in [additional] CompoundSelectStatement({ WithClause? withClause, required this.base, this.additional = const [], }) : super._(withClause); @override Iterable get childNodes { return [if (withClause != null) withClause!, base, ...additional]; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitCompoundSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); base = transformer.transformChild(base, this, arg); additional = transformer.transformChildren(additional, this, arg); } } /// A select statement of the form `VALUES (expr-list), ..., (expr-list-N)`. class ValuesSelectStatement extends BaseSelectStatement implements SelectStatementNoCompound { List values; ValuesSelectStatement(this.values, {WithClause? withClause}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitValuesSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { values = transformer.transformChildren(values, this, arg); } @override Iterable get childNodes => values; } abstract class ResultColumn extends AstNode { /// The acutal, schema-level [Column]s that this result column expands to. /// /// For a [ExpressionResultColumn], this is usually a singleton list with a /// single [ExpressionColumn]. For star columns, the list may return more /// elements. /// /// This list is populated during analysis, it will be `null` after parsing. /// Further, it may be left in its unset state if the column could not be /// analyzed due to an error. List? resolvedColumns; } /// A result column that either yields all columns or all columns from a table /// by using "*" or "table.*". class StarResultColumn extends ResultColumn { final String? tableName; StarResultColumn([this.tableName]); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitStarResultColumn(this, arg); } } class ExpressionResultColumn extends ResultColumn implements Renamable, Referencable { Expression expression; /// A drift-specific node to denote the type converter mapping this result /// column to Dart. MappedBy? mappedBy; @override final String? as; ExpressionResultColumn({required this.expression, this.mappedBy, this.as}); @override bool get visibleToChildren => false; @override Iterable get childNodes => [ expression, if (mappedBy != null) mappedBy!, ]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); mappedBy = transformer.transformNullableChild(mappedBy, this, arg); } @override R accept(AstVisitor visitor, A arg) { return visitor.visitExpressionResultColumn(this, arg); } } class GroupBy extends AstNode { /// The list of expressions that form the partition List by; Expression? having; GroupBy({required this.by, this.having}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitGroupBy(this, arg); } @override void transformChildren(Transformer transformer, A arg) { by = transformer.transformChildren(by, this, arg); having = transformer.transformNullableChild(having, this, arg); } @override Iterable get childNodes => [...by, if (having != null) having!]; } enum CompoundSelectMode { union, unionAll, intersect, except, } class CompoundSelectPart extends AstNode { final CompoundSelectMode mode; SelectStatementNoCompound select; /// The first token of this statement, so either union, intersect or except. Token? firstModeToken; /// The "ALL" token, if this is a "UNION ALL" part Token? allToken; CompoundSelectPart({required this.mode, required this.select}); @override Iterable get childNodes => [select]; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCompoundSelectPart(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } } lib/src/ast/clauses 755 0 0 0 0 12007 5ustar0 pubpublib/src/ast/clauses/ordering.dart 644 0 0 3217 14345646642 15153 0ustar0 pubpubpart of '../ast.dart'; /// Base for `ORDER BY` clauses. Without drift extensions, ony [OrderBy] will be /// parsed. Otherwise, [DartOrderByPlaceholder] can be parsed as well. abstract class OrderByBase extends AstNode {} /// Base for a single ordering term that is a part of a [OrderBy]. Without drift /// extensions, only [OrderingTerm] will be parsed. With drift extensions, a /// [DartOrderingTermPlaceholder] can be parsed as well. abstract class OrderingTermBase extends AstNode {} class OrderBy extends AstNode implements OrderByBase { List terms; OrderBy({this.terms = const []}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderBy(this, arg); } @override void transformChildren(Transformer transformer, A arg) { terms = transformer.transformChildren(terms, this, arg); } @override Iterable get childNodes => terms; } enum OrderingMode { ascending, descending } enum OrderingBehaviorForNulls { first, last } class OrderingTerm extends AstNode implements OrderingTermBase { Expression expression; OrderingMode? orderingMode; OrderingBehaviorForNulls? nulls; OrderingMode get resolvedOrderingMode => orderingMode ?? OrderingMode.ascending; OrderingTerm({required this.expression, this.orderingMode, this.nulls}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderingTerm(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } lib/src/ast/clauses/returning.dart 644 0 0 1354 14345646642 15357 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../statements/select.dart' show ResultColumn; import '../visitor.dart'; /// A returning clause describes expressions to evaluate after an insert, an /// update or a delete statement. class Returning extends AstNode { /// The `RETURNING` token as found in the source. Token? returning; List columns; Returning(this.columns); @override List get childNodes => columns; @override R accept(AstVisitor visitor, A arg) { return visitor.visitReturning(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); } } lib/src/ast/clauses/limit.dart 644 0 0 2073 14345646642 14457 0ustar0 pubpubpart of '../ast.dart'; /// Base for `LIMIT` clauses. Without drift extensions, only [Limit] will be /// parsed. With drift extensions, a [DartLimitPlaceholder] can be emitted as /// well. abstract class LimitBase implements AstNode {} class Limit extends AstNode implements LimitBase { Expression count; Token? offsetSeparator; // can either be OFFSET or just a comma Expression? offset; Limit({required this.count, this.offsetSeparator, this.offset}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitLimit(this, arg); } @override void transformChildren(Transformer transformer, A arg) { count = transformer.transformChild(count, this, arg); offset = transformer.transformNullableChild(offset, this, arg); } @override Iterable get childNodes { if (offsetSeparator?.type == TokenType.offset) { // Amount first, then offset return [count, offset!]; } // If using a comma, the count is followed by an optional offset return [count, if (offset != null) offset!]; } } lib/src/ast/clauses/with.dart 644 0 0 3334 14612235271 14302 0ustar0 pubpubpart of '../ast.dart'; class WithClause extends AstNode { Token? withToken; final bool recursive; Token? recursiveToken; List ctes; WithClause({required this.recursive, required this.ctes}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWithClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { ctes = transformer.transformChildren(ctes, this, arg); } @override Iterable get childNodes => ctes; } enum MaterializationHint { materialized, notMaterialized, } class CommonTableExpression extends AstNode with ResultSet { final String cteTableName; final MaterializationHint? materializationHint; /// The `not` token before the `materialized` token, if there is any. Token? not; /// The `materialized` token, if there is any. Token? materialized; /// If this common table expression has explicit column names, e.g. with /// `cnt(x) AS (...)`, contains the column names (`['x']`, in that case). /// Otherwise null. final List? columnNames; BaseSelectStatement as; Token? asToken; IdentifierToken? tableNameToken; @override List? resolvedColumns; CommonTableExpression({ required this.cteTableName, this.materializationHint, this.columnNames, required this.as, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCommonTableExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { as = transformer.transformChild(as, this, arg); } @override Iterable get childNodes => [as]; @override bool get visibleToChildren => true; } lib/src/ast/clauses/upsert.dart 644 0 0 4300 14345646642 14656 0ustar0 pubpubimport '../ast.dart'; // todo: Remove this import class UpsertClause extends AstNode { List entries; UpsertClause(this.entries); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpsertClause(this, arg); } @override List get childNodes => entries; @override void transformChildren(Transformer transformer, A arg) { entries = transformer.transformChildren(entries, this, arg); } } class UpsertClauseEntry extends AstNode implements HasWhereClause { List? onColumns; @override Expression? where; UpsertAction action; UpsertClauseEntry({this.onColumns, this.where, required this.action}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpsertClauseEntry(this, arg); } @override void transformChildren(Transformer transformer, A arg) { if (onColumns != null) { onColumns = transformer.transformChildren(onColumns!, this, arg); } where = transformer.transformNullableChild(where, this, arg); action = transformer.transformChild(action, this, arg); } @override Iterable get childNodes { return [ if (onColumns != null) ...onColumns!, if (where != null) where!, action, ]; } } abstract class UpsertAction extends AstNode {} class DoNothing extends UpsertAction { @override R accept(AstVisitor visitor, A arg) { return visitor.visitDoNothing(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; } class DoUpdate extends UpsertAction implements HasWhereClause { List set; @override Expression? where; DoUpdate(this.set, {this.where}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDoUpdate(this, arg); } @override void transformChildren(Transformer transformer, A arg) { set = transformer.transformChildren(set, this, arg); where = transformer.transformNullableChild(where, this, arg); } @override Iterable get childNodes => [...set, if (where != null) where!]; } lib/src/ast/drift 755 0 0 0 0 11460 5ustar0 pubpublib/src/ast/drift/declared_statement.dart 644 0 0 12450 14623415614 16651 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart' show Variable; import '../expressions/expressions.dart'; import '../node.dart'; import '../statements/statement.dart'; import '../statements/transaction.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// A declared statement inside a `.drift` file. It consists of an identifier, /// followed by a colon and the query to run. class DeclaredStatement extends Statement implements PartOfDriftFile { final DeclaredStatementIdentifier identifier; AstNode statement; List parameters; /// The desired result class name, if set. DriftTableName? as; Token? colon; /// Whether this is a regular query, meaning that Dart methods are generated /// for it. Special queries are annotated with an `@` and have special /// meaning. bool get isRegularQuery => identifier is SimpleName; DeclaredStatement(this.identifier, this.statement, {this.parameters = const [], this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statement = transformer.transformChild(statement, this, arg); parameters = transformer.transformChildren(parameters, this, arg); as = transformer.transformNullableChild(as, this, arg); } @override Iterable get childNodes => [statement, ...parameters, if (as != null) as!]; } /// How a statement was declared in a drift file. /// /// We support [SimpleName]s (`name: SELECT * FROM tbl`) and special keywords /// starting with an `@` in abstract class DeclaredStatementIdentifier { String get name; } /// The normal, named statement identifier for regular statements. class SimpleName extends DeclaredStatementIdentifier { @override final String name; IdentifierToken? identifier; SimpleName(this.name); @override int get hashCode => name.hashCode; @override bool operator ==(Object other) { return identical(this, other) || (other is SimpleName && other.name == name); } } /// A special statement identifier for statements declared with a `@`-name. /// /// Those names have a special meaning, like running a statement when the /// database is created. class SpecialStatementIdentifier extends DeclaredStatementIdentifier { final String specialName; AtSignVariableToken? nameToken; SpecialStatementIdentifier(this.specialName); @override int get hashCode => specialName.hashCode; @override String get name => specialName; @override bool operator ==(Object other) { return identical(this, other) || (other is SpecialStatementIdentifier && other.specialName == specialName); } } /// A statement parameter, which appears between brackets after the statement /// identifier. /// In `selectString(:name AS TEXT): SELECT :name`, `:name AS TEXT` is a /// statement parameter. abstract class StatementParameter extends AstNode implements DriftSpecificNode { @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } } /// Construct to explicitly set a variable type. /// /// Users can use `:name AS TYPE` as a statement parameter. Any use of `:name` /// in the query will then be resolved to the type set here. This is useful for /// cases in which the resolver doesn't yield acceptable results. class VariableTypeHint extends StatementParameter { Variable variable; final bool isRequired; final String? typeName; final bool orNull; Token? as; VariableTypeHint(this.variable, this.typeName, {this.orNull = false, this.isRequired = false}); @override Iterable get childNodes => [variable]; @override void transformChildren(Transformer transformer, A arg) { variable = transformer.transformChild(variable, this, arg); } } /// Set a default value for a dart placeholder. /// /// For instance, /// ``` /// query($predicate = TRUE): SELECT * FROM tbl WHERE $predicate; /// ``` /// /// Would generate an optional `predicate` parameter in Dart, having a default /// value of `CustomExpression('TRUE')`. class DartPlaceholderDefaultValue extends StatementParameter { final String variableName; Expression defaultValue; DollarSignVariableToken? variableToken; DartPlaceholderDefaultValue(this.variableName, this.defaultValue); @override Iterable get childNodes => [defaultValue]; @override void transformChildren(Transformer transformer, A arg) { defaultValue = transformer.transformChild(defaultValue, this, arg); } } class TransactionBlock extends AstNode implements DriftSpecificNode { BeginTransactionStatement begin; List innerStatements; CommitStatement commit; TransactionBlock({ required this.begin, required this.innerStatements, required this.commit, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override Iterable get childNodes => []; @override void transformChildren(Transformer transformer, A arg) { begin = transformer.transformChild(begin, this, arg); innerStatements = transformer.transformChildren(innerStatements, this, arg); commit = transformer.transformChild(commit, this, arg); } } lib/src/ast/drift/import_statement.dart 644 0 0 1270 14345646642 16406 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../statements/statement.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// An `import "file.dart";` statement that can appear inside a drift file. class ImportStatement extends Statement implements PartOfDriftFile { Token? importToken; StringLiteralToken? importString; final String importedFile; ImportStatement(this.importedFile); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override final Iterable childNodes = const []; } lib/src/ast/drift/drift_file.dart 644 0 0 3357 14612235271 15114 0ustar0 pubpubimport '../node.dart'; import '../statements/statement.dart'; import '../visitor.dart'; import 'declared_statement.dart'; import 'import_statement.dart'; /// Marker interface for AST nodes that are drift-specific. abstract class DriftSpecificNode implements AstNode {} /// Something that can appear as a top-level declaration inside a `.drift` file. abstract class PartOfDriftFile implements Statement, DriftSpecificNode {} /// A parsed `.drift` file. /// /// A drift file consists of [ImportStatement]s, followed by ddl statements, /// followed by [DeclaredStatement]s. class DriftFile extends AstNode implements DriftSpecificNode { List statements; DriftFile(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statements = transformer.transformChildren(statements, this, arg); } @override Iterable get childNodes => statements; /// Returns the imports defined in this file. Iterable get imports => childNodes.whereType(); } class DriftTableName extends AstNode implements DriftSpecificNode { final String overriddenDataClassName; final String? constructorName; final bool useExistingDartClass; DriftTableName({ required this.useExistingDartClass, required this.overriddenDataClassName, this.constructorName, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/drift/nested_query_column.dart 644 0 0 2641 14572643210 17065 0ustar0 pubpubimport '../ast.dart' show ResultColumn, Renamable, SelectStatement; import '../node.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// To wrap the query name into its own type, to avoid conflicts when using /// the [AstNode] metadata. class _NestedColumnNameMetadata { final String? name; _NestedColumnNameMetadata(this.name); } /// A nested query column, denoted by `LIST(...)` in user queries. /// /// Nested query columns take a select query and execute it for every result /// returned from the main query. Nested query columns can only be added to a /// top level select query, because the result of them can only be computed /// in dart. class NestedQueryColumn extends ResultColumn implements DriftSpecificNode, Renamable { @override final String? as; SelectStatement select; NestedQueryColumn({required this.select, this.as}); @override Iterable get childNodes => [select]; @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } /// The unique name for this query. Used to identify it and it's variables in /// the AST tree. set queryName(String? name) => setMeta(_NestedColumnNameMetadata(name)); String? get queryName => meta<_NestedColumnNameMetadata>()?.name; } lib/src/ast/drift/inline_dart.dart 644 0 0 5503 14345646642 15303 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; /// An inline Dart component that appears in a compiled sql query. Inline Dart /// components can be bound with complex expressions at runtime by using drift's /// Dart API. /// /// At the moment, we support 4 kind of inline components: /// 1. expressions: Any expression can be used for drift: `SELECT * FROM table /// = $expr`. Generated code will write this as an `Expression` class from /// drift. /// 2. limits, which will be exposed as a `Limit` component from drift /// 3. A single order-by clause, which will be exposed as a `OrderingTerm` from /// drift. /// 4. A list of order-by clauses, which will be exposed as a `OrderBy` from /// drift. abstract class DartPlaceholder extends AstNode implements DriftSpecificNode { final String name; DollarSignVariableToken? token; DartPlaceholder._(this.name); @override final Iterable childNodes = const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } T? when({ T Function(DartExpressionPlaceholder)? isExpression, T Function(DartLimitPlaceholder)? isLimit, T Function(DartOrderingTermPlaceholder)? isOrderingTerm, T Function(DartOrderByPlaceholder)? isOrderBy, T Function(DartInsertablePlaceholder)? isInsertable, }) { if (this is DartExpressionPlaceholder) { return isExpression?.call(this as DartExpressionPlaceholder); } else if (this is DartLimitPlaceholder) { return isLimit?.call(this as DartLimitPlaceholder); } else if (this is DartOrderingTermPlaceholder) { return isOrderingTerm?.call(this as DartOrderingTermPlaceholder); } else if (this is DartOrderByPlaceholder) { return isOrderBy?.call(this as DartOrderByPlaceholder); } else if (this is DartInsertablePlaceholder) { return isInsertable?.call(this as DartInsertablePlaceholder); } throw AssertionError('Invalid placeholder: $runtimeType'); } } class DartExpressionPlaceholder extends DartPlaceholder implements Expression { DartExpressionPlaceholder({required String name}) : super._(name); } class DartLimitPlaceholder extends DartPlaceholder implements LimitBase { DartLimitPlaceholder({required String name}) : super._(name); } class DartOrderingTermPlaceholder extends DartPlaceholder implements OrderingTermBase { DartOrderingTermPlaceholder({required String name}) : super._(name); } class DartOrderByPlaceholder extends DartPlaceholder implements OrderByBase { DartOrderByPlaceholder({required String name}) : super._(name); } class DartInsertablePlaceholder extends DartPlaceholder implements InsertSource { DartInsertablePlaceholder({required String name}) : super._(name); } lib/src/ast/drift/nested_star_result_column.dart 644 0 0 1652 14345646642 20302 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart' show StarResultColumn, ResultColumn, Renamable; import '../node.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// A nested star result column, denoted by `**` in user queries. /// /// Nested star result columns behave similar to a regular [StarResultColumn] /// when the query is actually run. However, they will affect generated code /// when using drift. class NestedStarResultColumn extends ResultColumn implements DriftSpecificNode, Renamable { final String tableName; ResultSet? resultSet; @override final String? as; NestedStarResultColumn({required this.tableName, this.as}); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } } lib/src/ast/common 755 0 0 0 0 11640 5ustar0 pubpublib/src/ast/common/tuple.dart 644 0 0 1615 14623415614 14314 0ustar0 pubpubpart of '../ast.dart'; /// A tuple of values, denotes in brackets. `(, ..., )`. /// /// In sqlite, this is also called a "row value". class Tuple extends Expression implements InExpressionTarget { /// The expressions appearing in this tuple. List expressions; /// Whether this tuple is used as an expression, e.g. a [row value][r v]. /// /// Other tuples might appear in `VALUES` clauses. /// /// [r v]: https://www.sqlite.org/rowvalue.html final bool usedAsRowValue; Tuple({required this.expressions, this.usedAsRowValue = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTuple(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expressions = transformer.transformChildren(expressions, this, arg); } @override List get childNodes => expressions; } lib/src/ast/common/renamable.dart 644 0 0 107 14345646642 15074 0ustar0 pubpubpart of '../ast.dart'; abstract class Renamable { String? get as; } lib/src/ast/common/queryables.dart 644 0 0 14714 14623415614 15363 0ustar0 pubpubpart of '../ast.dart'; /// Marker interface for something that can appear after a "FROM" in a select /// statement. abstract class Queryable extends AstNode { // todo remove this, introduce more visit methods for subclasses T when({ required T Function(TableReference) isTable, required T Function(SelectStatementAsSource) isSelect, required T Function(JoinClause) isJoin, required T Function(TableValuedFunction) isTableFunction, }) { if (this is TableReference) { return isTable(this as TableReference); } else if (this is SelectStatementAsSource) { return isSelect(this as SelectStatementAsSource); } else if (this is JoinClause) { return isJoin(this as JoinClause); } else if (this is TableValuedFunction) { return isTableFunction(this as TableValuedFunction); } throw StateError('Unknown subclass'); } } /// https://www.sqlite.org/syntax/table-or-subquery.html /// Marker interface abstract class TableOrSubquery extends Queryable { /// The result set that this node made available, if any ResultSetAvailableInStatement? availableResultSet; } /// A table. The first path in https://www.sqlite.org/syntax/table-or-subquery.html /// /// This is both referencable (if we have SELECT * FROM table t), other parts /// of the select statement can access "t") and a reference owner (the table). /// /// Note that this doesn't necessarily resolve to a result set. It could also /// resolve to a common table expression or anything else defining a result /// set. class TableReference extends TableOrSubquery with ReferenceOwner implements Renamable, ResolvesToResultSet, InExpressionTarget { final String? schemaName; final String tableName; Token? tableNameToken; @override final String? as; TableReference(this.tableName, {this.as, this.schemaName}); @override Iterable get childNodes => const []; @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableReference(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override ResultSet? get resultSet { return resolved as ResultSet?; } @override bool get visibleToChildren => true; } /// A nested select statement that appears after a FROM clause. This is /// different from nested select expressions, which can only return one value. class SelectStatementAsSource extends TableOrSubquery implements Renamable { @override final String? as; BaseSelectStatement statement; SelectStatementAsSource({required this.statement, this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectStatementAsSource(this, arg); } @override Iterable get childNodes => [statement]; @override void transformChildren(Transformer transformer, A arg) { statement = transformer.transformChild(statement, this, arg); } } /// https://www.sqlite.org/syntax/join-clause.html class JoinClause extends Queryable { TableOrSubquery primary; List joins; JoinClause({required this.primary, required this.joins}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoinClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { primary = transformer.transformChild(primary, this, arg); joins = transformer.transformChildren(joins, this, arg); } @override Iterable get childNodes => [primary, ...joins]; } enum JoinOperatorKind { none, // just JOIN, no other keywords comma, left, right, full, inner, cross; bool get supportsOuterKeyword { switch (this) { case JoinOperatorKind.left: case JoinOperatorKind.right: case JoinOperatorKind.full: return true; default: return false; } } } class JoinOperator extends AstNode { final bool natural; final bool outer; final JoinOperatorKind operator; JoinOperator( this.operator, { this.natural = false, this.outer = false, }); JoinOperator.comma() : natural = false, outer = false, operator = JoinOperatorKind.comma; @override Iterable get childNodes => const Iterable.empty(); @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoinOperator(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } class Join extends AstNode { JoinOperator operator; TableOrSubquery query; final JoinConstraint? constraint; Join({required this.operator, required this.query, this.constraint}); @override Iterable get childNodes { return [ operator, query, if (constraint is OnConstraint) (constraint as OnConstraint).expression ]; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoin(this, arg); } @override void transformChildren(Transformer transformer, A arg) { operator = transformer.transformChild(operator, this, arg); query = transformer.transformChild(query, this, arg); if (constraint is OnConstraint) { final onConstraint = constraint as OnConstraint; onConstraint.expression = transformer.transformChild(onConstraint.expression, this, arg); } } } /// https://www.sqlite.org/syntax/join-constraint.html abstract class JoinConstraint {} class OnConstraint extends JoinConstraint { Expression expression; OnConstraint({required this.expression}); } class UsingConstraint extends JoinConstraint { final List columnNames; UsingConstraint({required this.columnNames}); } class TableValuedFunction extends Queryable implements TableOrSubquery, SqlInvocation, Renamable, ResolvesToResultSet, InExpressionTarget { @override final String name; @override Token? nameToken; @override final String? as; @override FunctionParameters parameters; @override ResultSet? resultSet; TableValuedFunction(this.name, this.parameters, {this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableValuedFunction(this, arg); } @override Iterable get childNodes => [parameters]; @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); } @override bool get visibleToChildren => false; @override ResultSetAvailableInStatement? availableResultSet; } lib/src/utils 755 0 0 0 0 10721 5ustar0 pubpublib/src/utils/ast_equality.dart 644 0 0 56021 14711507160 14765 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:sqlparser/src/ast/ast.dart'; /// Checks whether [a] and [b] are equal. If they aren't, throws an exception. void enforceEqual(AstNode a, AstNode b) { EqualityEnforcingVisitor(a).visit(b, null); } void enforceEqualIterable(Iterable a, Iterable b) { final childrenA = a.iterator; final childrenB = b.iterator; var movedA = false; var movedB = false; // always move both iterators // need to store the result so it can be compared afterwards // since it does not get reverted if only one moved while ((movedA = childrenA.moveNext()) & (movedB = childrenB.moveNext())) { enforceEqual(childrenA.current, childrenB.current); } if (movedA || movedB) { throw ArgumentError("$a and $b don't have an equal amount of children"); } } /// Visitor enforcing the equality of two ast nodes. class EqualityEnforcingVisitor implements AstVisitor { // The current ast node. Visitor methods will compare the node they receive to // this one. AstNode _current; // Whether to check for deep equality too. final bool _considerChildren; /// Creates a visitor enforcing equality to the given node. /// /// The [visit] methods of this visitor will throw an [NotEqualException] /// if they receive a node that is different to the node passed here. /// /// When [considerChildren] is true (the default), it also considers child /// nodes, thus enforcing deep equality. EqualityEnforcingVisitor(this._current, {bool considerChildren = true}) : _considerChildren = considerChildren; @override void visitAggregateFunctionInvocation( AggregateFunctionInvocation e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitBeginTransaction(BeginTransactionStatement e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitBetweenExpression(BetweenExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitBinaryExpression(BinaryExpression e, void arg) { final current = _currentAs(e); _assert(current.operator.type == e.operator.type, e); _checkChildren(e); } @override void visitBlock(Block block, void arg) { _currentAs(block); _checkChildren(block); } @override void visitBooleanLiteral(BooleanLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value, e); _checkChildren(e); } @override void visitCaseExpression(CaseExpression e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCastExpression(CastExpression e, void arg) { final current = _currentAs(e); _assert(current.typeName == e.typeName, e); _checkChildren(e); } @override void visitCollateExpression(CollateExpression e, void arg) { final current = _currentAs(e); _assert(current.collateFunction.type == e.collateFunction.type, e); _checkChildren(e); } @override void visitColumnConstraint(ColumnConstraint e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); if (e is NotNull) { _assert(current is NotNull && current.onConflict == e.onConflict, e); } else if (e is PrimaryKeyColumn) { _assert( current is PrimaryKeyColumn && current.autoIncrement == e.autoIncrement && current.mode == e.mode && current.onConflict == e.onConflict, e); } else if (e is UniqueColumn) { _assert(current is UniqueColumn && current.onConflict == e.onConflict, e); } else if (e is CheckColumn) { _assert(current is CheckColumn, e); } else if (e is MappedBy) { _assert( current is MappedBy && current.mapper.dartCode == e.mapper.dartCode, e); } else if (e is JsonKey) { _assert(current is JsonKey && current.jsonKey == e.jsonKey, e); } else if (e is GeneratedAs) { _assert(current is GeneratedAs && current.stored == e.stored, e); } else { _assert(current.runtimeType == e.runtimeType, e); } _checkChildren(e); } @override void visitColumnDefinition(ColumnDefinition e, void arg) { final current = _currentAs(e); _assert( current.columnName == e.columnName && current.typeName == e.typeName, e); _checkChildren(e); } @override void visitCommitStatement(CommitStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { final current = _currentAs(e); _assert(current.cteTableName == e.cteTableName, e); _assert(current.materializationHint == e.materializationHint, e); _assert( const ListEquality().equals(current.columnNames, current.columnNames), e); _checkChildren(e); } @override void visitCompoundSelectPart(CompoundSelectPart e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCreateIndexStatement(CreateIndexStatement e, void arg) { final current = _currentAs(e); _assert( current.indexName == e.indexName && current.unique == e.unique && current.ifNotExists == e.ifNotExists, e); _checkChildren(e); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.tableName == e.tableName && current.withoutRowId == e.withoutRowId && current.isStrict == e.isStrict, e); _checkChildren(e); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.triggerName == e.triggerName && current.mode == e.mode, e); _checkChildren(e); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.viewName == e.viewName && const ListEquality().equals(current.columns, e.columns), e); _checkChildren(e); } @override void visitCreateVirtualTableStatement( CreateVirtualTableStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.tableName == e.tableName && current.moduleName == e.moduleName && const ListEquality() .equals(current.argumentContent, e.argumentContent), e); _checkChildren(e); } void visitDartPlaceholder(DartPlaceholder e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && current.runtimeType == e.runtimeType, e); _checkChildren(e); } @override void visitDefaultValues(DefaultValues e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDeferrableClause(DeferrableClause e, void arg) { final current = _currentAs(e); _assert( current.not == e.not && current.declaredInitially == e.declaredInitially, e); _checkChildren(e); } @override void visitDeleteStatement(DeleteStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDeleteTriggerTarget(DeleteTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDoNothing(DoNothing e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDoUpdate(DoUpdate e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitExists(ExistsExpression e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitExpressionFunctionParameters(ExprFunctionParameters e, void arg) { final current = _currentAs(e); _assert(current.distinct == e.distinct, e); _checkChildren(e); } @override void visitExpressionResultColumn(ExpressionResultColumn e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitForeignKeyClause(ForeignKeyClause e, void arg) { final current = _currentAs(e); _assert( current.onDelete == e.onDelete && current.onUpdate == e.onUpdate, e); _checkChildren(e); } @override void visitFrameSpec(FrameSpec e, void arg) { final current = _currentAs(e); _assert( current.type == e.type && current.excludeMode == e.excludeMode && current.start == e.start && e.end == e.end, e); _checkChildren(e); } @override void visitFunction(FunctionExpression e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitGroupBy(GroupBy e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitIndexedColumn(IndexedColumn e, void arg) { final current = _currentAs(e); _assert(current.ordering == e.ordering, e); _checkChildren(e); } @override void visitInExpression(InExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitInsertStatement(InsertStatement e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitInsertTriggerTarget(InsertTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitInvalidStatement(InvalidStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitIsExpression(IsExpression e, void arg) { final current = _currentAs(e); _assert(current.negated == e.negated, e); _assert(current.distinctFromSyntax == e.distinctFromSyntax, e); _checkChildren(e); } @override void visitIsNullExpression(IsNullExpression e, void arg) { final current = _currentAs(e); _assert(current.negated == e.negated, e); _checkChildren(e); } @override void visitJoin(Join e, void arg) { final current = _currentAs(e); final constraint = current.constraint; if (constraint is OnConstraint) { _assert(e.constraint is OnConstraint, e); } else if (constraint is UsingConstraint) { if (e.constraint is! UsingConstraint) { _notEqual(e); } final typedOther = e.constraint as UsingConstraint; _assert( const ListEquality() .equals(constraint.columnNames, typedOther.columnNames), e); } _checkChildren(e); } @override void visitJoinOperator(JoinOperator e, void arg) { final current = _currentAs(e); _assert( e.natural == current.natural && e.outer == current.outer && e.operator == current.operator, e); _checkChildren(e); } @override void visitJoinClause(JoinClause e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitLimit(Limit e, void arg) { _currentAs(e); _checkChildren(e); } void visitDriftDeclaredStatement(DeclaredStatement e, void arg) { final current = _currentAs(e); _assert(current.identifier == e.identifier, e); _checkChildren(e); } void visitDriftFile(DriftFile e, void arg) { _currentAs(e); _checkChildren(e); } void visitDriftImportStatement(ImportStatement e, void arg) { final current = _currentAs(e); _assert(current.importedFile == e.importedFile, e); _checkChildren(e); } void visitDriftNestedStarResultColumn(NestedStarResultColumn e, void arg) { final current = _currentAs(e); _assert(current.tableName == e.tableName, e); _assert(current.as == e.as, e); _checkChildren(e); } void visitDriftNestedQueryColumn(NestedQueryColumn e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is DartPlaceholder) { return visitDartPlaceholder(e, arg); } else if (e is DeclaredStatement) { return visitDriftDeclaredStatement(e, arg); } else if (e is DriftFile) { return visitDriftFile(e, arg); } else if (e is ImportStatement) { return visitDriftImportStatement(e, arg); } else if (e is NestedStarResultColumn) { return visitDriftNestedStarResultColumn(e, arg); } else if (e is StatementParameter) { return visitDriftStatementParameter(e, arg); } else if (e is DriftTableName) { return visitDriftTableName(e, arg); } else if (e is NestedQueryColumn) { return visitDriftNestedQueryColumn(e, arg); } } void visitDriftStatementParameter(StatementParameter e, void arg) { if (e is VariableTypeHint) { final current = _currentAs(e); _assert( current.typeName == e.typeName && current.orNull == e.orNull && current.isRequired == e.isRequired, e); } else if (e is DartPlaceholderDefaultValue) { final current = _currentAs(e); _assert(current.variableName == e.variableName, e); } _checkChildren(e); } void visitDriftTableName(DriftTableName e, void arg) { final current = _currentAs(e); _assert( current.overriddenDataClassName == e.overriddenDataClassName && current.constructorName == e.constructorName && current.useExistingDartClass == e.useExistingDartClass, e); } @override void visitNamedVariable(ColonNamedVariable e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitNullLiteral(NullLiteral e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitNumberedVariable(NumberedVariable e, void arg) { final current = _currentAs(e); _assert(current.explicitIndex == e.explicitIndex, e); _checkChildren(e); } @override void visitNumericLiteral(NumericLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value, e); _checkChildren(e); } @override void visitOrderBy(OrderBy e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitOrderingTerm(OrderingTerm e, void arg) { final current = _currentAs(e); _assert( current.orderingMode == e.orderingMode && current.nulls == e.nulls, e); _checkChildren(e); } @override void visitParentheses(Parentheses e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitRaiseExpression(RaiseExpression e, void arg) { final current = _currentAs(e); _assert( current.raiseKind == e.raiseKind && current.errorMessage == e.errorMessage, e, ); _checkChildren(e); } @override void visitReference(Reference e, void arg) { final current = _currentAs(e); _assert( current.schemaName == e.schemaName && current.entityName == e.entityName && current.columnName == e.columnName, e); _checkChildren(e); } @override void visitReturning(Returning e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitSelectInsertSource(SelectInsertSource e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitSelectStatement(SelectStatement e, void arg) { final current = _currentAs(e); _assert(current.distinct == e.distinct, e); _checkChildren(e); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitSemicolonSeparatedStatements( SemicolonSeparatedStatements e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitSingleColumnSetComponent(SingleColumnSetComponent e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitMultiColumnSetComponent(MultiColumnSetComponent e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitStarFunctionParameter(StarFunctionParameter e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitStarResultColumn(StarResultColumn e, void arg) { final current = _currentAs(e); _assert(current.tableName == e.tableName, e); _checkChildren(e); } @override void visitStringComparison(StringComparisonExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitStringLiteral(StringLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value && current.isBinary == e.isBinary, e); _checkChildren(e); } @override void visitSubQuery(SubQuery e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitTableConstraint(TableConstraint e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && e.constraintEquals(current), e); _checkChildren(e); } @override void visitTableReference(TableReference e, void arg) { final current = _currentAs(e); _assert( current.schemaName == e.schemaName && current.tableName == e.tableName && current.as == e.as, e); _checkChildren(e); } @override void visitTableValuedFunction(TableValuedFunction e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitTimeConstantLiteral(TimeConstantLiteral e, void arg) { final current = _currentAs(e); _assert(current.kind == e.kind, e); _checkChildren(e); } @override void visitTuple(Tuple e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUnaryExpression(UnaryExpression e, void arg) { final current = _currentAs(e); _assert(current.operator.type == e.operator.type, e); _checkChildren(e); } @override void visitUpdateStatement(UpdateStatement e, void arg) { final current = _currentAs(e); _assert(current.or == e.or, e); _checkChildren(e); } @override void visitUpdateTriggerTarget(UpdateTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUpsertClause(UpsertClause e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUpsertClauseEntry(UpsertClauseEntry e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitValuesSource(ValuesSource e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitWhen(WhenComponent e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && current.windowName == e.windowName, e); _checkChildren(e); } @override void visitWindowDefinition(WindowDefinition e, void arg) { final current = _currentAs(e); _assert(current.baseWindowName == e.baseWindowName, e); _checkChildren(e); } @override void visitWithClause(WithClause e, void arg) { final current = _currentAs(e); _assert(current.recursive == e.recursive, e); _checkChildren(e); } void _assert(bool contentEqual, AstNode context) { if (!contentEqual) _notEqual(context); } void _check(AstNode? childOfCurrent, AstNode? childOfOther) { if (identical(childOfCurrent, childOfOther)) return; if ((childOfCurrent == null) != (childOfOther == null)) { throw NotEqualException('$childOfCurrent and $childOfOther'); } // Both non nullable here final savedCurrent = _current; _current = childOfCurrent!; visit(childOfOther!, null); _current = savedCurrent; } void _checkChildren(AstNode other) { if (!_considerChildren) return; final currentChildren = _current.childNodes.iterator; final otherChildren = other.childNodes.iterator; while (currentChildren.moveNext()) { if (otherChildren.moveNext()) { _check(currentChildren.current, otherChildren.current); } else { // Current has more elements than other throw NotEqualException( "$_current and $other don't have an equal amount of children"); } } if (otherChildren.moveNext()) { // Other has more elements than current throw NotEqualException( "$_current and $other don't have an equal amount of children (${_current.childNodes.length} and ${other.childNodes.length})"); } } T _currentAs(T context) { final current = _current; if (current is T) return current; _notEqual(context); } Never _notEqual(AstNode other) { throw NotEqualException('$_current and $other'); } } /// Thrown by the [EqualityEnforcingVisitor] when two nodes were determined to /// be non-equal. class NotEqualException implements Exception { final String message; NotEqualException(this.message); @override String toString() { return 'Not equal: $message'; } } lib/src/utils/meta.dart 644 0 0 1416 14345646642 13201 0ustar0 pubpub/// Mixin for types that can have arbitrary metadata on them. mixin HasMetaMixin { final Map _metadata = {}; /// Returns the metadata of type [T] that might have been set on this node, or /// null if none was found. /// Nodes can have arbitrary annotations on them set via [setMeta] and /// obtained via [meta]. This mechanism is used to, for instance, attach /// variable scopes to a subtree. T? meta() { return _metadata[T] as T?; } /// Sets the metadata of type [T] to the specified [value]. /// Nodes can have arbitrary annotations on them set via [setMeta] and /// obtained via [meta]. This mechanism is used to, for instance, attach /// variable scopes to a subtree. void setMeta(T value) { _metadata[T] = value; } } lib/src/analysis 755 0 0 0 0 11404 5ustar0 pubpublib/src/analysis/steps 755 0 0 0 0 12542 5ustar0 pubpublib/src/analysis/steps/linting_visitor.dart 644 0 0 51152 14711507160 17325 0ustar0 pubpubpart of '../analysis.dart'; /// Visitor that runs after all other steps ran and reports more complex lints /// on an sql statement. class LintingVisitor extends RecursiveVisitor { final EngineOptions options; final AnalysisContext context; bool _isInTopLevelTriggerStatement = false; LintingVisitor(this.options, this.context); @override void visitBaseSelectStatement(BaseSelectStatement stmt, void arg) { if (_isInTopLevelTriggerStatement) { // If this select statement is used as a subqery, we're no longer in a // top-level trigger statements. final saved = _isInTopLevelTriggerStatement; _isInTopLevelTriggerStatement = stmt.parent is Block; super.visitBaseSelectStatement(stmt, arg); _isInTopLevelTriggerStatement = saved; } else { super.visitBaseSelectStatement(stmt, arg); } } @override void visitBinaryExpression(BinaryExpression e, void arg) { final operator = e.operator.type; if ((operator == TokenType.dashRangle || operator == TokenType.dashRangleRangle) && options.version < SqliteVersion.v3_38) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: '`->` and `->>` require sqlite3 version 38', relevantNode: e.operator, )); } visitChildren(e, arg); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { if (e.materializationHint != null && options.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'MATERIALIZED / NOT MATERIALIZED requires sqlite3 version 35', relevantNode: e.materialized ?? e, )); } visitChildren(e, arg); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final schemaReader = SchemaFromCreateTable(driftExtensions: options.useDriftExtensions); var hasNonGeneratedColumn = false; var hasPrimaryKeyDeclaration = false; var isStrict = false; if (e.isStrict) { if (options.version < SqliteVersion.v3_37) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'STRICT tables are only supported from sqlite3 version 37', relevantNode: e.strict ?? e, )); } else { // only report warnings related to STRICT tables if strict tables are // supported. isStrict = true; } } // Ensure that a table declaration only has one PRIMARY KEY constraint void handlePrimaryKeyNode(AstNode node) { if (hasPrimaryKeyDeclaration) { context.reportError(AnalysisError( type: AnalysisErrorType.duplicatePrimaryKeyDeclaration, message: 'Duplicate PRIMARY KEY constraint found', relevantNode: node, )); } hasPrimaryKeyDeclaration = true; } for (final column in e.columns) { if (isStrict) { final typeName = column.typeName; if (typeName == null) { // Columns in strict tables must have a type name, even if it's // `ANY`. context.reportError(AnalysisError( type: AnalysisErrorType.noTypeNameInStrictTable, message: 'In `STRICT` tables, columns must have a type name!', relevantNode: column.nameToken ?? column, )); } else if (!schemaReader.isValidTypeNameForStrictTable(typeName)) { context.reportError(AnalysisError( type: AnalysisErrorType.invalidTypeNameInStrictTable, message: 'Invalid type name for a `STRICT` table.', relevantNode: column.typeNames?.toSingleEntity ?? column, )); } } var isGenerated = false; for (final constraint in column.constraints) { isGenerated = isGenerated || constraint is GeneratedAs; if (constraint is PrimaryKeyColumn) { handlePrimaryKeyNode(constraint); } } if (!isGenerated) { hasNonGeneratedColumn = true; } } for (final constraint in e.tableConstraints) { if (constraint is KeyClause && constraint.isPrimaryKey) { handlePrimaryKeyNode(constraint); } } if (e.withoutRowId && !hasPrimaryKeyDeclaration) { context.reportError( AnalysisError( type: AnalysisErrorType.missingPrimaryKey, message: 'Missing PRIMARY KEY declaration for a table without rowid.', relevantNode: e.tableNameToken ?? e, ), ); } if (!hasNonGeneratedColumn) { context.reportError( AnalysisError( type: AnalysisErrorType.allColumnsAreGenerated, message: 'This table is missing a non-generated column', relevantNode: e.tableNameToken ?? e, ), ); } visitChildren(e, arg); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final topLevelBefore = _isInTopLevelTriggerStatement; _isInTopLevelTriggerStatement = true; if (e.onTable.resultSet?.unalias() case final on?) { if (on is View && !e.mode.isSupportedOnViews) { context.reportError(AnalysisError( type: AnalysisErrorType.invalidTriggerMode, relevantNode: e.onTable, message: 'Only `INSTEAD OF` triggers are allowed for views.', )); } else if (on is Table && !e.mode.isSupportedOnTables) { context.reportError(AnalysisError( type: AnalysisErrorType.invalidTriggerMode, relevantNode: e.onTable, message: '`INSTEAD OF` triggers are only allowed on views.', )); } } visitChildren(e, arg); _isInTopLevelTriggerStatement = topLevelBefore; } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { final resolvedColumns = e.query.resolvedColumns; if (e.columns == null || resolvedColumns == null) { return super.visitCreateViewStatement(e, arg); } final amountOfNames = e.columns!.length; final amountOfColumns = resolvedColumns.length; if (amountOfNames != amountOfColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.viewColumnNamesMismatch, relevantNode: e, message: 'This view declares $amountOfNames column names, but the ' 'inner select statement returns $amountOfColumns', )); } visitChildren(e, arg); } @override void visitDefaultValues(DefaultValues e, void arg) { // `DEFAULT VALUES` is not supported in a trigger, see https://www.sqlite.org/lang_insert.html if (_isInTopLevelTriggerStatement) { context.reportError( AnalysisError( type: AnalysisErrorType.synctactic, message: '`DEFAULT VALUES` cannot be used in a trigger.', relevantNode: e, ), ); } visitChildren(e, arg); } @override void visitInExpression(InExpression e, void arg) { final expectedColumns = switch (e.left) { Tuple(:var expressions) => expressions.length, _ => 1, }; switch (e.inside) { case Tuple tuple: for (final element in tuple.expressions) { final actualColumns = switch (element) { Tuple(:var expressions) => expressions.length, _ => 1, }; if (expectedColumns != actualColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.other, message: 'Expected $expectedColumns columns in this entry, got ' '$actualColumns', relevantNode: element, )); } } case SubQuery subquery: final columns = subquery.select.resolvedColumns; if (columns != null && columns.length != expectedColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.other, message: 'The subquery must return $expectedColumns columns, ' 'it returns ${columns.length}', relevantNode: subquery, )); } case TableOrSubquery table: final columns = table.availableResultSet?.resultSet.resultSet?.resolvedColumns; if (columns != null && columns.length != expectedColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.other, message: 'To be used in this `IN` expression, this table must ' 'have $expectedColumns columns (it has ${columns.length}).', relevantNode: table, )); } } visitChildren(e, arg); } @override void visitIsExpression(IsExpression e, void arg) { if (e.distinctFromSyntax && options.version < SqliteVersion.v3_39) { // `IS NOT DISTINCT FROM` is the same thing as `IS` final alternative = e.negated ? 'IS' : 'IS NOT'; final source = (e.distinct != null && e.from != null) ? [e.distinct!, e.from!].toSingleEntity : e; context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: '`DISTINCT FROM` requires sqlite 3.39, try using `$alternative`', relevantNode: source, )); } visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { for (final target in e.targetColumns) { final resolved = target.resolvedColumn; if (resolved is TableColumn && resolved.isGenerated) { context.reportError( AnalysisError( type: AnalysisErrorType.writeToGeneratedColumn, message: "This column is generated, and generated columns can't " 'be inserted.', relevantNode: target, ), ); } } visitChildren(e, arg); } @override void visitExpressionFunctionParameters(ExprFunctionParameters e, void arg) { if (e.distinct && e.parameters.length != 1) { context.reportError(AnalysisError( type: AnalysisErrorType.distinctAggregateWithWrongParameterCount, message: 'A `DISTINCT` aggregate must have exactly one argument', relevantNode: e.distinctKeyword ?? e, )); } visitChildren(e, arg); } @override void visitInvocation(SqlInvocation e, void arg) { final lowercaseCall = e.name.toLowerCase(); if (options.addedFunctions.containsKey(lowercaseCall)) { options.addedFunctions[lowercaseCall]!.reportErrors(e, context); } final lowerCaseName = e.name.toLowerCase(); if (lowerCaseName == 'printf' && options.version >= SqliteVersion.v3_38) { // `printf` was renamed to `format` in sqlite3 version 3.38 if (options.version >= SqliteVersion.v3_38) { context.reportError( AnalysisError( type: AnalysisErrorType.hint, message: '`printf` was renamed to `format()`, consider using ' 'that function instead.', relevantNode: e, ), ); } } // Warn when newer functions are used in an unsupported sqlite3 version. final minimumVersion = switch (lowerCaseName) { 'format' || 'unixepoch' => SqliteVersion.v3_38, 'unhex' => SqliteVersion.v3_41, 'timediff' || 'octet_length' => SqliteVersion.v3_43, 'concat' || 'concat_ws' || 'string_agg' => SqliteVersion.v3_44, _ => null, }; if (minimumVersion != null && options.version < minimumVersion) { final versionStr = '${minimumVersion.major}.${minimumVersion.minor}'; context.reportError( AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: '`${e.name}` requires sqlite $versionStr or later', relevantNode: e.nameToken ?? e, ), ); } visitChildren(e, arg); } @override void visitJoinOperator(JoinOperator e, void arg) { if ((e.operator == JoinOperatorKind.right || e.operator == JoinOperatorKind.full) && options.version < SqliteVersion.v3_39) { context.reportError( AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: '`RIGHT` and `FULL` joins require sqlite 3.39.', relevantNode: e, ), ); } } @override void visitRaiseExpression(RaiseExpression e, void arg) { if (!_isInTopLevelTriggerStatement) { context.reportError(AnalysisError( type: AnalysisErrorType.raiseMisuse, relevantNode: e, message: 'RAISE can only be used in a trigger.', )); } } @override void visitReturning(Returning e, void arg) { // RETURNING was added in sqlite version 3.35.0 if (context.engineOptions.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'RETURNING requires sqlite version 3.35 or later', relevantNode: e, )); return; } // https://www.sqlite.org/lang_returning.html#limitations_and_caveats // Returning is not allowed in triggers if (_isInTopLevelTriggerStatement) { context.reportError(AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'RETURNING is not allowed in triggers', relevantNode: e, )); } // Returning is not allowed against virtual tables final parent = e.parent; if (parent is HasPrimarySource) { final source = parent.table; if (source is TableReference) { final referenced = source.resultSet?.unalias(); if (referenced is Table && referenced.isVirtual) { context.reportError(AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'RETURNING is not allowed against virtual tables', relevantNode: e, )); } } } for (final column in e.columns) { // Table wildcards are not currently allowed, see // https://www.sqlite.org/src/info/132994c8b1063bfb if (column is StarResultColumn && column.tableName != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Columns in RETURNING may not use the TABLE.* syntax', relevantNode: column, )); } else if (column is ExpressionResultColumn) { // While we're at it, window expressions aren't allowed either if (column.expression is WindowFunctionInvocation) { context.reportError( AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'Aggregate expressions are not allowed in RETURNING', relevantNode: column.expression, ), ); } } } visitChildren(e, arg); } void _checkForGeneratedColumn(Reference column) { final target = column.resolvedColumn; if (target is TableColumn && target.isGenerated) { context.reportError( AnalysisError( type: AnalysisErrorType.writeToGeneratedColumn, message: 'This column is generated, and generated columns cannot be ' 'updated explicitly.', relevantNode: column, ), ); } } @override void visitSingleColumnSetComponent(SingleColumnSetComponent e, void arg) { _checkForGeneratedColumn(e.column); visitChildren(e, arg); } @override void visitMultiColumnSetComponent(MultiColumnSetComponent e, void arg) { for (final column in e.columns) { _checkForGeneratedColumn(column); } if (e.rowValue is Tuple && e.columns.length != (e.rowValue as Tuple).expressions.length) { context.reportError( AnalysisError( type: AnalysisErrorType.cteColumnCountMismatch, message: 'Length of column-name-list must match length of row values.', relevantNode: e.rowValue, ), ); } else if (e.rowValue is SubQuery && e.columns.length != (e.rowValue as SubQuery).select.resolvedColumns?.length) { context.reportError( AnalysisError( type: AnalysisErrorType.cteColumnCountMismatch, message: 'Length of column-name-list must match length of columns returned by SubQuery.', relevantNode: e.rowValue, ), ); } visitChildren(e, arg); } @override void visitTableConstraint(TableConstraint e, void arg) { if (e is KeyClause && e.isPrimaryKey) { // Primary key clauses may only include simple columns for (final column in e.columns) { final expr = column.expression; if (expr is! Reference || expr.entityName != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Only column names can be used in a PRIMARY KEY clause', relevantNode: expr, )); } } } visitChildren(e, arg); } @override void visitTableReference(TableReference e, void arg) { final parent = e.parent; if (parent is HasPrimarySource && parent.table == e) { // The source of a `INSERT`, `UPDATE` or `DELETE` statement must not have // an alias in `CREATE TRIGGER` statements. if (_isInTopLevelTriggerStatement && e.as != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'The source must not have an `AS` alias when used in a trigger.', relevantNode: e, )); } } visitChildren(e, arg); } @override void visitTuple(Tuple e, void arg) { if (!e.usedAsRowValue) return; bool isRowValue(Expression? expr) => expr is Tuple || expr is SubQuery; var parent = e.parent; var isAllowed = false; if (parent is WhenComponent && e == parent.when) { // look at the surrounding case expression parent = parent.parent; } if (parent is BinaryExpression) { // Source: https://www.sqlite.org/rowvalue.html#syntax const allowedTokens = [ TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, TokenType.equal, TokenType.doubleEqual, TokenType.lessMore, TokenType.$is, ]; if (allowedTokens.contains(parent.operator.type)) { isAllowed = true; } } else if (parent is BetweenExpression) { // Allowed if all value are row values or subqueries isAllowed = !parent.childNodes.any((e) => !isRowValue(e)); } else if (parent is CaseExpression) { // Allowed if we have something to compare against and all comparisons // are row values if (parent.base == null) { isAllowed = false; } else { final comparisons = [ parent.base, for (final branch in parent.whens) branch.when ]; isAllowed = !comparisons.any((e) => !isRowValue(e)); } } else if (parent is InExpression) { // For in expressions we have a more accurate analysis on whether tuples // are allowed that looks at both the LHS and the RHS. isAllowed = true; } else if (parent is SetComponent) { isAllowed = true; } if (!isAllowed) { context.reportError(AnalysisError( type: AnalysisErrorType.rowValueMisuse, relevantNode: e, message: 'Row values can only be used as expressions in comparisons', )); } } @override void visitUpsertClause(UpsertClause e, void arg) { final hasMultipleClauses = e.entries.length > 1; if (hasMultipleClauses && options.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, relevantNode: e, message: 'Multiple on conflict clauses require sqlite version 3.35 or later', )); } visitChildren(e, arg); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { final expectedColumns = e.resolvedColumns!.length; for (final tuple in e.values) { final elementsInTuple = tuple.expressions.length; if (elementsInTuple != expectedColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.valuesSelectCountMismatch, relevantNode: tuple, message: 'The surrounding VALUES clause has $expectedColumns ' 'columns, but this tuple only has $elementsInTuple', )); } } visitChildren(e, arg); } @override void visitWithClause(WithClause e, void arg) { if (_isInTopLevelTriggerStatement) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, relevantNode: e.withToken ?? e, message: 'WITH clauses cannot appear in triggers.', )); } visitChildren(e, arg); } } lib/src/analysis/steps/prepare_ast.dart 644 0 0 22051 14623415614 16407 0ustar0 pubpubpart of '../analysis.dart'; /// Prepares the AST for further analysis. This visitor /// - creates [ReferenceScope]s for sub-queries /// - in each scope, registers every table or subquery that can be referenced to /// the local [ReferenceScope]. /// - determines the [Variable.resolvedIndex] for each [Variable] in this /// statement. /// - reports syntactic errors that aren't handled in the parser to keep that /// implementation simpler. class AstPreparingVisitor extends RecursiveVisitor { final List _foundVariables = []; final AnalysisContext context; AstPreparingVisitor({required this.context}); void start(AstNode root) { root.accept(this, null); resolveIndexOfVariables(_foundVariables); } @override void visitAggregateFunctionInvocation( AggregateFunctionInvocation e, void arg) { if (e.orderBy != null && context.engineOptions.version < SqliteVersion.v3_44) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'ORDER BY in aggregate functions require sqlite 3.44 or later.', relevantNode: e.orderBy, )); } super.visitAggregateFunctionInvocation(e, arg); } @override void defaultInsertSource(InsertSource e, void arg) { e.scope = SourceScope(e.parent!.statementScope); visitChildren(e, arg); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final scope = e.scope = StatementScope.forStatement(context.rootScope, e); final knownTable = context.rootScope.knownTables[e.tableName]; // This is used so that tables can refer to their own columns. Code using // tables would first register the table and then run analysis again. if (knownTable is Table) { scope ..expansionOfStarColumn = knownTable.resolvedColumns ..resultSets[null] = ResultSetAvailableInStatement(e, knownTable); } visitChildren(e, arg); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { e.scope = StatementScope.forStatement(context.rootScope, e); visitChildren(e, arg); } @override void visitSelectStatement(SelectStatement e, void arg) { // a select statement can appear as a sub query which has its own scope, so // we need to fork the scope here. There is one special case though: // Select statements that appear as a query source can't depend on data // defined in the outer scope. This is different from select statements // that work as expressions. // For instance, if you go to sqliteonline.com and issue the following // query: "SELECT * FROM demo d1, // (SELECT * FROM demo i WHERE i.id = d1.id) d2;" // it won't work. final isInFROM = e.parent is Queryable; StatementScope scope; if (isInFROM) { final surroundingSelect = e.parents .firstWhere((node) => node is HasFrom) .scope as StatementScope; scope = StatementScope(SourceScope(surroundingSelect)); } else { scope = StatementScope.forStatement(context.rootScope, e); } e.scope = scope; for (final windowDecl in e.windowDeclarations) { scope.windowDeclarations[windowDecl.name] = windowDecl; } // only the last statement in a compound select statement may have an order // by or a limit clause if (e.parent is CompoundSelectPart || e.parent is CompoundSelectStatement) { bool isLast; if (e.parent is CompoundSelectPart) { final part = e.parent as CompoundSelectPart; final compoundSelect = part.parent as CompoundSelectStatement; final index = compoundSelect.additional.indexOf(part); isLast = index == compoundSelect.additional.length - 1; } else { // if the parent is the compound select statement, this select query is // the [CompoundSelectStatement.base], so definitely not the last query. isLast = false; } if (!isLast) { if (e.limit != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Limit clause must appear in the last compound statement', relevantNode: e.limit, )); } if (e.orderBy != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Order by clause must appear in the compound statement', relevantNode: e.orderBy, )); } } } visitChildren(e, arg); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { StatementScope.cast(e.scope).additionalKnownTables[e.cteTableName] = e; visitChildren(e, arg); } @override void visitInExpression(InExpression e, void arg) { // The RHS can use everything from the parent scope, but it can't add new // table references that would be visible to others. e.scope = StatementScope(e.scope); visitChildren(e, arg); } @override void visitNumberedVariable(NumberedVariable e, void arg) { _foundVariables.add(e); visitChildren(e, arg); } @override void visitNamedVariable(ColonNamedVariable e, void arg) { _foundVariables.add(e); visitChildren(e, arg); } static void resolveIndexOfVariables(List variables) { // sort variables by the order in which they appear inside the statement. variables.sort((a, b) { return a.firstPosition.compareTo(b.firstPosition); }); // Assigning rules are explained at https://www.sqlite.org/lang_expr.html#varparam var largestAssigned = 0; final resolvedNames = {}; for (final variable in variables) { if (variable is NumberedVariable) { // if the variable has an explicit index (e.g ?123), then 123 is the // resolved index and the next variable will have index 124. Otherwise, // just assigned the current largest assigned index plus one. if (variable.explicitIndex != null) { final index = variable.resolvedIndex = variable.explicitIndex!; largestAssigned = max(largestAssigned, index); } else { variable.resolvedIndex = largestAssigned + 1; largestAssigned++; } } else if (variable is ColonNamedVariable) { // named variables behave just like numbered vars without an explicit // index, but of course two variables with the same name must have the // same index. final index = resolvedNames.putIfAbsent(variable.name, () { return ++largestAssigned; }); variable.resolvedIndex = index; } } } @override void defaultNode(AstNode e, void arg) { // hack to fork scopes on statements (selects are handled above) if (e is Statement && e is! SelectStatement) { e.scope = StatementScope.forStatement(context.rootScope, e); } visitChildren(e, arg); } @override void visitUpsertClause(UpsertClause e, void arg) { for (var i = 0; i < e.entries.length; i++) { _visitUpsertClauseEntry(e.entries[i], i == e.entries.length - 1); } } void _visitUpsertClauseEntry(UpsertClauseEntry e, bool isLast) { // Every DoUpdate except for the last ON CONFLICT clause must have a // conflict target. When using older sqlite versions, every clause needs // a conflict target. final lastWithoutTargetOk = context.engineOptions.version >= SqliteVersion.v3_35; final withoutTargetOk = lastWithoutTargetOk && isLast; if (e.onColumns == null && e.action is DoUpdate && !withoutTargetOk) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Expected a conflict clause when using DO UPDATE', relevantNode: e.action, )); } // DO UPDATE clauses have their own reference scope, in which the row // "excluded" can be referred. Setting that row happens in the column // resolver if (e.action is DoUpdate) { e.action.scope = MiscStatementSubScope(e.scope as StatementScope); } visitChildren(e, null); } /// If a nested query was found. Collect everything separately. @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is NestedQueryColumn) { // create a new scope for the nested query to differentiate between // references that can be resolved in the nested query and references // which require data from the parent query e.select.scope = MiscStatementSubScope(e.scope as StatementScope); } super.visitDriftSpecificNode(e, arg); } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { // Window functions can't use ORDER BY in their arguments: // https://github.com/sqlite/sqlite/blob/85b1f5c2f6a05ba151496122fc62b10d560498ca/src/expr.c#L1231-L1235 if (e.orderBy != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Window functions may not use `ORDER BY` in their parameter list', relevantNode: e.orderBy, )); } super.visitWindowFunctionInvocation(e, arg); } } lib/src/analysis/steps/reference_resolver.dart 644 0 0 12346 14612235271 17764 0ustar0 pubpubpart of '../analysis.dart'; /// Resolves any open [Reference] it finds in the AST. class ReferenceResolver extends RecursiveVisitor { final AnalysisContext context; ReferenceResolver(this.context); @override void visitInsertStatement(InsertStatement e, ReferenceResolvingContext arg) { final table = e.table.resultSet; if (table != null) { // Resolve columns in the main table for (final column in e.targetColumns) { _resolveReferenceInTable(column, table); } } visitChildren(e, arg); } @override void visitGroupBy(GroupBy e, ReferenceResolvingContext arg) { return super.visitGroupBy( e, const ReferenceResolvingContext(canReferToColumnAlias: true)); } @override void visitOrderBy(OrderBy e, ReferenceResolvingContext arg) { return super.visitOrderBy( e, ReferenceResolvingContext(canReferToColumnAlias: true)); } @override void visitReference(Reference e, ReferenceResolvingContext arg) { if (e.resolved != null) { return super.visitReference(e, arg); } final scope = e.scope; if (e.entityName != null) { // first find the referenced table or view, // then use the column on that table or view. final entityResolver = scope.resolveResultSetForReference(e.entityName!); final resultSet = entityResolver?.resultSet.resultSet; if (resultSet == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table or view: ${e.entityName}', relevantNode: e, )); } else { _resolveReferenceInTable(e, resultSet, source: entityResolver); } } else if (aliasesForRowId.contains(e.columnName.toLowerCase())) { // special case for aliases to a rowid final column = _resolveRowIdAlias(e); if (column == null) { _reportUnknownColumnError(e); } else { e.resolved = column; } } else { // find any column with the referenced name. // todo special case for USING (...) in joins? final found = scope.resolveUnqualifiedReference( e.columnName, allowReferenceToResultColumn: arg.canReferToColumnAlias, ); if (found.isEmpty) { _reportUnknownColumnError(e); } else { if (found.length > 1) { final description = found.map((c) => c.humanReadableDescription()).join(', '); context.reportError(AnalysisError( type: AnalysisErrorType.ambiguousReference, relevantNode: e, message: 'Could refer to any of: $description', )); } e.resolved = found.first; } } visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, ReferenceResolvingContext arg) { final table = e.table.resultSet; if (table != null) { // Resolve the set components against the primary table for (final set in e.set) { for (final column in set.columns) { _resolveReferenceInTable(column, table); } } } visitChildren(e, arg); } @override void visitWindowFunctionInvocation( WindowFunctionInvocation e, ReferenceResolvingContext arg) { if (e.windowName != null && e.resolved == null) { e.resolved = StatementScope.cast(e.scope).windowDeclarations[e.windowName!]; } visitChildren(e, arg); } void _reportUnknownColumnError(Reference e, {Iterable? columns}) { final msg = StringBuffer('Unknown column.'); if (columns != null) { final columnNames = columns.map((c) => c.humanReadableDescription()).join(', '); msg.write(' These columns are available: $columnNames'); } context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownColumn, relevantNode: e, message: msg.toString(), )); } void _resolveReferenceInTable(Reference ref, ResultSet resultSet, {ResultSetAvailableInStatement? source}) { var column = resultSet.findColumn(ref.columnName); if (column == null) { _reportUnknownColumnError(ref, columns: resultSet.resolvedColumns); } else { if (source != null) { column = AvailableColumn(column, source); } ref.resolved = column; ref.resultEntity = source; } } Column? _resolveRowIdAlias(Reference e) { // to resolve those aliases when they're not bound to a table, the // surrounding statement may only read from one table final stmt = e.enclosingOfType(); if (stmt == null) return null; final from = stmt.table; if (from is! TableReference) { return null; } final resolved = from.resultSet?.unalias(); if (resolved is! Table) return null; // table.findColumn contains logic to resolve row id aliases return resolved.findColumn(e.columnName); } } class ReferenceResolvingContext { /// Whether unqualified references can be resolved against a column alias from /// the surrounding select statement. /// /// This is only the case for `ORDER BY`, `GROUP BY` and `HAVING` clauses. final bool canReferToColumnAlias; const ReferenceResolvingContext({ this.canReferToColumnAlias = false, }); } lib/src/analysis/steps/column_resolver.dart 644 0 0 52371 14623415614 17330 0ustar0 pubpubpart of '../analysis.dart'; /// Walks the AST and, for each select statement it sees, finds out which /// columns are returned and which columns are available. For instance, when /// we have a table "t" with two columns "a" and "b", the select statement /// "SELECT a FROM t" has one result column but two columns available. class ColumnResolver extends RecursiveVisitor { final AnalysisContext context; ColumnResolver(this.context); @override void visitSelectStatement(SelectStatement e, ColumnResolverContext arg) { e.withClause?.accept(this, arg); _resolveSelect(e, arg); // We've handled the from clause in _resolveSelect, but we still need to // visit other children to handle things like subquery expressions. for (final child in e.childNodes) { if (child != e.withClause && child != e.from) { visit(child, arg); } } } @override void visitCreateIndexStatement( CreateIndexStatement e, ColumnResolverContext arg) { _handle(e.on, [], arg); visitExcept(e, e.on, arg); } @override void visitCreateTriggerStatement( CreateTriggerStatement e, ColumnResolverContext arg) { final table = _resolveTableReference(e.onTable, arg); if (table == null) { // further analysis is not really possible without knowing the table super.visitCreateTriggerStatement(e, arg); return; } final scope = e.statementScope; if (e.target.introducesNew) { scope.addAlias(e, table, 'new', canUseUnqualifiedColumns: false); } if (e.target.introducesOld) { scope.addAlias(e, table, 'old', canUseUnqualifiedColumns: false); } if (e.target case final UpdateTarget onUpdate) { onUpdate.scope = SingleTableReferenceScope(scope, e.onTable.tableName, ResultSetAvailableInStatement(e.onTable, table)); } visitChildren(e, arg); } @override void visitCompoundSelectStatement( CompoundSelectStatement e, ColumnResolverContext arg) { e.withClause?.accept(this, arg); e.base.accept(this, arg); visitList(e.additional, arg); _resolveCompoundSelect(e); } @override void visitValuesSelectStatement( ValuesSelectStatement e, ColumnResolverContext arg) { e.withClause?.accept(this, arg); _resolveValuesSelect(e); // Still visit expressions because they could have subqueries that we need // to handle. visitList(e.values, arg); } @override void visitCommonTableExpression( CommonTableExpression e, ColumnResolverContext arg) { // If we have a compound select statement as a CTE, resolve the initial // query first because the whole CTE will have those columns in the end. // This allows subsequent parts of the compound select to refer to the CTE. final query = e.as; final contextForFirstChild = ColumnResolverContext( referencesUseNameOfReferencedColumn: false, inDefinitionOfCte: [ ...arg.inDefinitionOfCte, e.cteTableName.toLowerCase(), ], ); void applyColumns(BaseSelectStatement source) { final resolved = source.resolvedColumns!; final names = e.columnNames; if (names == null) { e.resolvedColumns = resolved; } else { if (names.length != resolved.length) { context.reportError(AnalysisError( type: AnalysisErrorType.cteColumnCountMismatch, message: 'This CTE declares ${names.length} columns, but its select ' 'statement actually returns ${resolved.length}.', relevantNode: e.tableNameToken ?? e, )); } final cteColumns = names .map((name) => CommonTableExpressionColumn(name)..containingSet = e) .toList(); for (var i = 0; i < cteColumns.length; i++) { if (i < resolved.length) { final selectColumn = resolved[i]; cteColumns[i].innerColumn = selectColumn; } } e.resolvedColumns = cteColumns; } } if (query is CompoundSelectStatement) { // The first nested select statement determines the columns of this CTE. query.base.accept(this, contextForFirstChild); applyColumns(query.base); // Subsequent queries can refer to the CTE though. final contextForOtherChildren = ColumnResolverContext( referencesUseNameOfReferencedColumn: false, inDefinitionOfCte: arg.inDefinitionOfCte, ); visitList(query.additional, contextForOtherChildren); _resolveCompoundSelect(query); } else { visitChildren(e, contextForFirstChild); applyColumns(query); } } @override void visitDoUpdate(DoUpdate e, ColumnResolverContext arg) { final surroundingInsert = e.parents.whereType().first; final table = surroundingInsert.table.resultSet; if (table != null) { // add "excluded" table qualifier that referring to the row that would // have been inserted had the uniqueness constraint not been violated. e.scope.addAlias(e, table, 'excluded'); } visitChildren(e, arg); } @override void visitForeignKeyClause(ForeignKeyClause e, ColumnResolverContext arg) { final resolved = _resolveTableReference(e.foreignTable, arg); final scope = SingleTableReferenceScope( e.scope, e.foreignTable.tableName, resolved != null ? ResultSetAvailableInStatement(e.foreignTable, resolved) : null, ); e.scope = scope; visitExcept(e, e.foreignTable, arg); } @override void visitInExpression(InExpression e, ColumnResolverContext arg) { if (e.inside case Queryable query) { _handle(query, [], arg); visitExcept(e, e.inside, arg); } else { super.visitInExpression(e, arg); } } @override void visitUpdateStatement(UpdateStatement e, ColumnResolverContext arg) { // Resolve CTEs first e.withClause?.accept(this, arg); final availableColumns = []; // Add columns from the main table, if it was resolved _handle(e.table, availableColumns, arg); // Also add columns from a FROM clause, if one is present final from = e.from; if (from != null) _handle(from, availableColumns, arg); e.statementScope.expansionOfStarColumn = availableColumns; for (final child in e.childNodes) { // Visit remaining children if (child != e.table && child != e.from && child != e.withClause) { visit(child, arg); } } _resolveReturningClause(e, e.table.resultSet, arg); } ResultSet? _addIfResolved( AstNode node, TableReference ref, ColumnResolverContext arg) { final availableColumns = []; _handle(ref, availableColumns, arg); final scope = node.statementScope; scope.expansionOfStarColumn = availableColumns; return ref.resultSet; } @override void visitInsertStatement(InsertStatement e, ColumnResolverContext arg) { // Resolve CTEs first e.withClause?.accept(this, arg); _handle(e.table, [], arg); for (final child in e.childNodes) { if (child != e.withClause) visit(child, arg); } _resolveReturningClause(e, e.table.resultSet, arg); } @override void visitDeleteStatement(DeleteStatement e, ColumnResolverContext arg) { // Resolve CTEs first e.withClause?.accept(this, arg); final from = _addIfResolved(e, e.from, arg); for (final child in e.childNodes) { if (child != e.withClause) visit(child, arg); } _resolveReturningClause(e, from, arg); } /// Infers the result set of a `RETURNING` clause. /// /// The behavior of `RETURNING` clauses is a bit weird when there are multiple /// tables available (which can happen with `UPDATE FROM`). When a star column /// is used, it only expands to columns from the main table: /// ```sql /// CREATE TABLE x (a, b); /// -- here, the `*` in returning does not include columns from `old`. /// UPDATE x SET a = x.a + 1 FROM (SELECT * FROM x) AS old RETURNING *; /// ``` /// /// However, individual columns from other tables are available and supported: /// ```sql /// UPDATE x SET a = x.a + 1 FROM (SELECT * FROM x) AS old /// RETURNING old.a, old.b; /// ``` /// /// Note that `old.*` is forbidden by sqlite and not applicable here. void _resolveReturningClause( StatementReturningColumns stmt, ResultSet? mainTable, ColumnResolverContext context, ) { final clause = stmt.returning; if (clause == null) return; final columns = _resolveColumns( stmt.statementScope, clause.columns, context, columnsForStar: mainTable?.resolvedColumns, ); stmt.returnedResultSet = CustomResultSet(columns); } /// Visits a [queryable] appearing in a `FROM` clause under the state [state]. /// /// This also adds columns contributed to the resolved source to /// [availableColumns], which is later used to expand `*` parameters. void _handle(Queryable queryable, List availableColumns, ColumnResolverContext state) { void addColumns(Iterable columns) { ResultSetAvailableInStatement? available; if (queryable is TableOrSubquery) { available = queryable.availableResultSet; } if (available != null) { availableColumns.addAll( [for (final column in columns) AvailableColumn(column, available)]); } else { availableColumns.addAll(columns); } } final scope = queryable.scope; void markAvailableResultSet( Queryable source, ResolvesToResultSet resultSet, String? name) { final added = ResultSetAvailableInStatement(source, resultSet); if (source is TableOrSubquery) { source.availableResultSet = added; } scope.addResolvedResultSet(name, added); } queryable.when( isTable: (table) { final resolved = _resolveTableReference(table, state); markAvailableResultSet( table, resolved ?? table, table.as ?? table.tableName); if (resolved != null) { addColumns(table.resultSet!.resolvedColumns!); } }, isSelect: (select) { markAvailableResultSet(select, select.statement, select.as); // Inside subqueries, references don't take the name of the referenced // column. final childState = ColumnResolverContext( referencesUseNameOfReferencedColumn: false, inDefinitionOfCte: state.inDefinitionOfCte, ); final stmt = select.statement; visit(stmt, childState); addColumns(stmt.resolvedColumns!); }, isJoin: (joinClause) { _handle(joinClause.primary, availableColumns, state); for (final join in joinClause.joins) { _handle(join.query, availableColumns, state); final constraint = join.constraint; if (constraint is OnConstraint) { visit(constraint.expression, state); } } }, isTableFunction: (function) { final handler = context .engineOptions.addedTableFunctions[function.name.toLowerCase()]; var resolved = handler?.resolveTableValued(context, function); // Virtual tables can also be used as table-valued functions, so try to // resolve a table otherwise. if (resolved == null) { final table = scope.resolveResultSetToAdd(function.name); if (table is Table && table.isVirtual) { resolved = function.as != null ? TableAlias(table, function.as!) : table; } } markAvailableResultSet( function, resolved ?? function, function.as ?? function.name); if (resolved == null) { context.reportError(AnalysisError( type: AnalysisErrorType.unknownFunction, message: 'Could not extract the result set for this table function', relevantNode: function, )); } else { function.resultSet = resolved; addColumns(resolved.resolvedColumns!); } }, ); } void _resolveSelect(SelectStatement s, ColumnResolverContext context) { final availableColumns = []; if (s.from != null) { _handle(s.from!, availableColumns, context); } final scope = s.statementScope; scope.expansionOfStarColumn = availableColumns; s.resolvedColumns = _resolveColumns(scope, s.columns, context); } List _resolveColumns(StatementScope scope, List columns, ColumnResolverContext state, {List? columnsForStar}) { final usedColumns = []; final availableColumns = [...?scope.expansionOfStarColumn]; // a select statement can include everything from its sub queries as a // result, but also expressions that appear as result columns for (final resultColumn in columns) { if (resultColumn is StarResultColumn) { Iterable visibleColumnsForStar; if (resultColumn.tableName != null) { final tableResolver = scope.resolveResultSetForReference(resultColumn.tableName!); if (tableResolver == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); continue; } visibleColumnsForStar = tableResolver .resultSet.resultSet?.resolvedColumns ?.map((tableColumn) => AvailableColumn(tableColumn, tableResolver)) ?? const []; } else { // we have a * column without a table, that resolves to every column // available visibleColumnsForStar = columnsForStar ?? scope.expansionOfStarColumn ?? const []; // Star columns can't be used without a table (e.g. `SELECT *` is // not allowed) if (scope.resultSets.isEmpty) { context.reportError(AnalysisError( type: AnalysisErrorType.starColumnWithoutTable, message: "Can't use * when no tables have been added", relevantNode: resultColumn, )); } } final added = visibleColumnsForStar.where((e) => e.includedInResults).toList(); usedColumns.addAll(added); resultColumn.resolvedColumns = added; } else if (resultColumn is ExpressionResultColumn) { final expression = resultColumn.expression; Column column; if (expression is Reference) { var fixedName = resultColumn.as; if (!state.referencesUseNameOfReferencedColumn) { fixedName = _nameOfResultColumn(resultColumn); } column = ReferenceExpressionColumn( expression, overriddenName: fixedName, mappedBy: resultColumn.mappedBy, ); } else { final name = _nameOfResultColumn(resultColumn)!; column = ExpressionColumn( name: name, expression: resultColumn.expression, mappedBy: resultColumn.mappedBy, ); } usedColumns.add(column); resultColumn.resolvedColumns = [column]; if (resultColumn.as != null) { // make this column available for references if there is no other // column with the same name final name = resultColumn.as; if (!availableColumns.any((c) => c.name == name)) { availableColumns.add(column); scope.namedResultColumns.add(column); } } } else if (resultColumn is NestedStarResultColumn) { final target = scope.resolveResultSetForReference(resultColumn.tableName); if (target == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); continue; } resultColumn.resultSet = target.resultSet.resultSet; } else if (resultColumn is NestedQueryColumn) { _resolveSelect(resultColumn.select, state); } } return usedColumns; } void _resolveCompoundSelect(CompoundSelectStatement statement) { final columnSets = [ statement.base.resolvedColumns, for (var part in statement.additional) part.select.resolvedColumns ]; // each select statement must return the same amount of columns final amount = columnSets.first!.length; for (var i = 1; i < columnSets.length; i++) { if (columnSets[i]!.length != amount) { context.reportError(AnalysisError( type: AnalysisErrorType.compoundColumnCountMismatch, relevantNode: statement, message: 'The parts of this compound statement return different ' 'amount of columns', )); break; } } final resolved = []; // merge all columns at each position into a CompoundSelectColumn for (var i = 0; i < amount; i++) { final columnsAtThisIndex = [ for (var set in columnSets) if (set!.length > i) set[i] ]; resolved.add( CompoundSelectColumn(columnsAtThisIndex)..containingSet = statement); } statement.resolvedColumns = resolved; } void _resolveValuesSelect(ValuesSelectStatement statement) { // ideally all tuples should have the same arity, but the parser doesn't // enforce that. final amountOfColumns = statement.values.fold(null, (maxLength, tuple) { final lengthHere = tuple.expressions.length; return maxLength == null ? lengthHere : max(maxLength, lengthHere); })!; final columns = []; for (var i = 0; i < amountOfColumns; i++) { // Columns in a VALUES clause appear to be named "Column$i", where i is a // one-based index. final columnName = 'Column${i + 1}'; final expressions = statement.values .where((tuple) => tuple.expressions.length > i) .map((tuple) => tuple.expressions[i]) .toList(); columns.add(ValuesSelectColumn(columnName, expressions) ..containingSet = statement); } statement.resolvedColumns = columns; } String? _nameOfResultColumn(ExpressionResultColumn c) { if (c.as != null) return c.as; if (c.expression is Reference) { return (c.expression as Reference).columnName; } // in this case it's just the literal expression. So for instance, // "SELECT 3+ 5" has a result column called "3+ 5" (consecutive whitespace // is removed). final span = context.sql.substring(c.firstPosition, c.lastPosition); // todo remove consecutive whitespace return span; } ResultSet? _resolveTableReference( TableReference r, ColumnResolverContext state) { // Check for circular references if (state.inDefinitionOfCte.contains(r.tableName.toLowerCase())) { context.reportError(AnalysisError( type: AnalysisErrorType.circularReference, relevantNode: r, message: 'Circular reference to its own CTE', )); return null; } final scope = r.scope; // Try resolving to a top-level table in the schema and to a result set that // may have been added to the table final resolvedInSchema = scope.resolveResultSetToAdd(r.tableName); final createdName = r.as; if (resolvedInSchema != null) { return r.resolved = createdName != null ? TableAlias(resolvedInSchema, createdName) : resolvedInSchema; } else { Iterable? available; if (scope is StatementScope) { available = StatementScope.cast(scope) .allAvailableResultSets .where((e) => e.resultSet.resultSet != null) .map((t) { final resultSet = t.resultSet.resultSet; if (resultSet is HumanReadable) { return (resultSet as HumanReadable).humanReadableDescription(); } return t.toString(); }); } context.reportError(UnresolvedReferenceError( type: AnalysisErrorType.referencedUnknownTable, relevantNode: r, reference: r.tableName, available: available ?? const Iterable.empty(), )); } return null; } } class ColumnResolverContext { /// Whether reference columns should use the name of the referenced column as /// their own name (as opposed to their lexeme). /// /// This typically doesn't make a difference, as references uses the same /// name as the referenced column. It does make a difference for rowid /// references though: /// /// ```sql /// CREATE TABLE foo (id INTEGER NOT NULL PRIMARY KEY); /// /// SELECT rowid FROM foo; -- returns a column named "id" /// SELECT * FROM (SELECT rowid FROM foo); -- returns a column named "rowid" /// WITH bar AS (SELECT rowid FROM foo) SELECT * FROM bar; -- again, "rowid" /// ``` /// /// As the example shows, references don't take the name of their referenced /// column in subqueries or CTEs. final bool referencesUseNameOfReferencedColumn; /// The common table expressions that are currently being defined. /// /// This is used to detect forbidden circular references. final List inDefinitionOfCte; const ColumnResolverContext({ this.referencesUseNameOfReferencedColumn = true, this.inDefinitionOfCte = const [], }); } lib/src/analysis/steps/set_parent_visitor.dart 644 0 0 570 14345646642 17777 0ustar0 pubpubpart of '../analysis.dart'; /// Sets the [AstNode.parent] property for each node in a tree. class SetParentVisitor { const SetParentVisitor(); void startAtRoot(AstNode root) { _applyFor(root, null); } void _applyFor(AstNode node, AstNode? parent) { node.parent = parent; for (final child in node.childNodes) { _applyFor(child, node); } } } lib/src/analysis/schema 755 0 0 0 0 12644 5ustar0 pubpublib/src/analysis/schema/result_set.dart 644 0 0 5416 14612235271 16360 0ustar0 pubpubpart of '../analysis.dart'; /// Something that will resolve to an [ResultSet] when referred to via /// the [ReferenceScope]. abstract class ResolvesToResultSet with Referencable { ResultSet? get resultSet; } /// Something that returns a set of columns when evaluated. abstract mixin class ResultSet implements ResolvesToResultSet { /// The columns that will be returned when evaluating this query. List? get resolvedColumns; @override ResultSet get resultSet => this; @override bool get visibleToChildren => false; Column? findColumn(String name) { final lowerName = name.toLowerCase(); return resolvedColumns! .firstWhereOrNull((c) => c.name.toLowerCase() == lowerName); } } /// A custom result set that has columns but isn't a table. class CustomResultSet with ResultSet { @override final List resolvedColumns; CustomResultSet(this.resolvedColumns); } /// Something that returns a set of Columns and can be referenced by a name, /// such as a table or a view. abstract class NamedResultSet extends ResultSet { /// The name of this result set, as it appears in sql statements. This should /// be the raw name, not an escaped version. /// /// To obtain an escaped name, use [escapedName]. String get name; /// If [name] is a reserved sql keyword, wraps it in double ticks. Otherwise /// just returns the [name] directly. String get escapedName { return isKeywordLexeme(name) ? '"$name"' : name; } } /// Information about a result set that is available in a statement. /// /// Regular result sets include tables or views that are available globally. /// However, columns from those result sets can't be used in statements unless /// the result set appears in a `FROM` clause or a similar construct. /// /// This class stores information about added result sets and the syntactic /// construct that added them. class ResultSetAvailableInStatement with Referencable { /// The node responsible for adding the [resultSet]. /// /// This may typically be a [TableOrSubquery] appearing a `FROM` clause. final AstNode origin; /// The added result set. final ResolvesToResultSet resultSet; /// Whether this result set should be considered when resolving unqualified /// references. /// /// This is true for most result sets, but some aliases such as the `old` and /// `new` result sets in triggers can only be used with a qualified reference. final bool canUseUnqualifiedColumns; @override bool get visibleToChildren => true; ResultSetAvailableInStatement(this.origin, this.resultSet, {this.canUseUnqualifiedColumns = true}); } extension UnaliasResultSet on ResultSet { ResultSet unalias() { var $this = this; while ($this is TableAlias) { $this = $this.delegate; } return $this; } } lib/src/analysis/schema/table.dart 644 0 0 6500 14345646642 15264 0ustar0 pubpubpart of '../analysis.dart'; /// The aliases which can be used to refer to the rowid of a table. See /// https://www.sqlite.org/lang_createtable.html#rowid const aliasesForRowId = ['rowid', 'oid', '_rowid_']; /// A database table. The information stored here will be used to resolve /// references and for type inference. class Table extends NamedResultSet with HasMetaMixin implements HumanReadable { /// The name of this table, as it appears in sql statements. This should be /// the raw name, not an escaped version. /// /// To obtain an escaped name, use [escapedName]. @override final String name; @override final List resolvedColumns; /// Filter the [resolvedColumns] for those that are /// [Column.includedInResults]. List get resultColumns => resolvedColumns.where((c) => c.includedInResults).toList(); /// Whether this table was created with an "WITHOUT ROWID" modifier final bool withoutRowId; final bool isStrict; /// Additional constraints set on this table. final List tableConstraints; /// The ast node that created this table final TableInducingStatement? definition; /// Whether this is a virtual table. final bool isVirtual; @override bool get visibleToChildren => true; TableColumn? _rowIdColumn; /// Constructs a table from the known [name] and [resolvedColumns]. Table({ required this.name, required this.resolvedColumns, this.withoutRowId = false, this.isStrict = false, this.tableConstraints = const [], this.definition, this.isVirtual = false, }) { for (final column in resolvedColumns) { column.table = this; if (_rowIdColumn == null) { if (column is RowId) { _rowIdColumn = column; } else if (column.isAliasForRowId()) { _rowIdColumn = column; // By design, the rowid is non-nullable, even if there isn't a NOT NULL // constraint set on the column definition. column._type = const ResolvedType(type: BasicType.int, nullable: false); } } } } @override Column? findColumn(String name) { final defaultSearch = super.findColumn(name); if (defaultSearch != null) return defaultSearch; // handle aliases to rowids, see https://www.sqlite.org/lang_createtable.html#rowid if (aliasesForRowId.contains(name.toLowerCase()) && !withoutRowId) { return _rowIdColumn ?? RowId() ..table = this; } return null; } @override String humanReadableDescription() { return name; } @override String toString() => 'Table $name'; } class TableAlias extends NamedResultSet implements HumanReadable { final ResultSet delegate; final String alias; TableAlias(this.delegate, this.alias); @override String get name => alias; @override List get resolvedColumns => delegate.resolvedColumns!; @override Column? findColumn(String name) => delegate.findColumn(name); @override ResultSet get resultSet => this; @override bool get visibleToChildren => delegate.visibleToChildren; @override String humanReadableDescription() { final delegateDescription = delegate is HumanReadable ? (delegate as HumanReadable).humanReadableDescription() : delegate.toString(); return '$alias (alias to $delegateDescription)'; } } lib/src/analysis/schema/references.dart 644 0 0 33663 14623415614 16340 0ustar0 pubpubpart of '../analysis.dart'; /// Mixin for classes which represent a reference. mixin ReferenceOwner { /// The resolved reference, or null if it hasn't been resolved yet. Referencable? resolved; } /// Mixin for classes which can be referenced by a [ReferenceOwner]. mixin Referencable { /// Whether this referencable is still visible in child scopes. This doesn't /// apply to many things, basically only to tables. /// /// For instance: "SELECT *, 1 AS d, (SELECT id FROM demo WHERE id = out.id) /// FROM demo AS out;" /// is a valid sql query when the demo table has an id column. However, /// "SELECT *, 1 AS d, (SELECT id FROM demo WHERE id = d) FROM demo AS out;" /// is not, the "d" referencable is not visible for the child select /// statement. bool get visibleToChildren => false; } /// A class managing which tables and columns are visible to which AST nodes. abstract class ReferenceScope { RootScope get rootScope; /// All available result sets that can also be seen in child scopes. /// /// Usually, this is the same list as the result sets being declared in this /// scope. However, some exceptions apply (see e.g. [SourceScope]). Iterable get resultSetAvailableToChildScopes => const Iterable.empty(); /// The list of column to which a `*` would expand to. /// /// This is not necessary the same list of columns that could be resolved /// through [resolveUnqualifiedReference]. For subquery expressions, columns /// in parent scopes may be referenced without a qualified, but they don't /// appear in a `*` expansion for the subquery. List? get expansionOfStarColumn => null; /// Attempts to find a result set that has been added to this scope, for /// instance because it was introduced in a `FROM` clause. /// /// This is useful to resolve qualified references (e.g. to resolve `foo.bar` /// the resolver would call [resolveResultSet]("foo") and then look up the /// `bar` column in that result set). ResultSetAvailableInStatement? resolveResultSetForReference(String name) => null; /// Adds an added result set to this scope. /// /// This operation is not supported for all kinds of scopes, a [StateError] /// is thrown for invalid scopes. void addResolvedResultSet( String? name, ResultSetAvailableInStatement resultSet) { throw StateError('Result set cannot be added in this scope: $this'); } /// Registers a [ResultSetAvailableInStatement] to a [TableAlias] for the /// given [resultSet]. /// /// Like [addResolvedResultSet], this operation is not supported on all /// scopes. /// /// [canUseUnqualifiedColumns] controls whether [resolveUnqualifiedReference] /// considers the alias when resolving references. Some aliases, such as `new` /// and `old` in triggers, can only be used in their qualified form and thus /// have that parameter set to false. void addAlias( AstNode origin, ResultSet resultSet, String alias, { bool canUseUnqualifiedColumns = true, }) { final createdAlias = TableAlias(resultSet, alias); addResolvedResultSet( alias, ResultSetAvailableInStatement(origin, createdAlias, canUseUnqualifiedColumns: canUseUnqualifiedColumns), ); } /// Attempts to find a result set that _can_ be added to a scope. /// /// This is used to resolve table references. Usually, after a result set to /// add has been resolve,d a [ResultSetAvailableInStatement] is added to the /// scope and [resolveResultSet] will find that afterwards. ResultSet? resolveResultSetToAdd(String name) { return rootScope.resolveResultSetToAdd(name); } /// Attempts to resolve an unqualified reference from a [columnName]. /// /// In sqlite, an `ORDER BY` column may refer to aliases of result columns /// in the current statement: `SELECT foo AS bar FROM tbl ORDER BY bar` is /// legal, but `SELECT foo AS bar FROM tbl WHERE bar < 10` is not. To control /// whether result columns may be resolved, the [allowReferenceToResultColumn] /// flag can be enabled. /// /// If an empty list is returned, the reference couldn't be resolved. If the /// returned list contains more than one column, the lookup is ambigious. List resolveUnqualifiedReference(String columnName, {bool allowReferenceToResultColumn = false}) => const []; } /// The root scope created by the SQL engine to analyze a statement. /// /// This contains known tables (or views) and modules to look up. class RootScope extends ReferenceScope { @override RootScope get rootScope => this; /// All tables (or views, or other result sets) that are known in the current /// schema. /// /// [resolveResultSetToAdd] will query these tables by default. final Map knownTables = CaseInsensitiveMap(); /// Known modules that are registered for this statement. /// /// This is used to resolve `CREATE VIRTUAL TABLE` statements. final Map knownModules = CaseInsensitiveMap(); @override ResultSet? resolveResultSetToAdd(String name) { return knownTables[name]; } } mixin _HasParentScope on ReferenceScope { ReferenceScope get _parentScopeForLookups; @override RootScope get rootScope => _parentScopeForLookups.rootScope; @override Iterable get resultSetAvailableToChildScopes => _parentScopeForLookups.resultSetAvailableToChildScopes; @override ResultSetAvailableInStatement? resolveResultSetForReference(String name) => _parentScopeForLookups.resolveResultSetForReference(name); @override ResultSet? resolveResultSetToAdd(String name) => _parentScopeForLookups.resolveResultSetToAdd(name); @override List resolveUnqualifiedReference(String columnName, {bool allowReferenceToResultColumn = false}) => _parentScopeForLookups.resolveUnqualifiedReference(columnName); } /// A scope used by statements. /// /// Tables added from `FROM` clauses are added to [resultSets], CTEs are added /// to [additionalKnownTables]. /// /// This is the scope most commonly used, but specific nodes may be attached to /// a different scope in case they have limited visibility. For instance, /// - foreign key clauses are wrapped in a [SingleTableReferenceScope] because /// they can't see unqualified columns of the overal scope. /// - subquery expressions can see parent tables and columns, but their columns /// aren't visible in the parent statement. This is implemented by wrapping /// them in a [StatementScope] as well. /// - subqueries appearing in a `FROM` clause _can't_ see outer columns and /// tables. These statements are also wrapped in a [StatementScope], but a /// [SourceScope] is inserted as an intermediate scope to prevent the inner /// scope from seeing the outer columns. class StatementScope extends ReferenceScope with _HasParentScope { final ReferenceScope parent; @override get _parentScopeForLookups => parent; /// Additional tables (that haven't necessarily been added in a `FROM` clause /// that are only visible in this scope). /// /// This is commonly used for common table expressions, e.g a `WITH foo AS /// (...)` would add a result set `foo` into the [additionalKnownTables] of /// the overall statement, because `foo` can now be selected. final Map additionalKnownTables = CaseInsensitiveMap(); /// Result sets that were added through a `FROM` clause and are now available /// in this scope. /// /// The [ResultSetAvailableInStatement] contains information about the AST /// node causing this statement to be available. final Map resultSets = CaseInsensitiveMap(); /// For select statements, additional columns available under a name because /// there were added after the `SELECT`. /// /// This is used to resolve unqualified references by `ORDER BY` clauses. final List namedResultColumns = []; final Map windowDeclarations = CaseInsensitiveMap(); /// All columns that a (unqualified) `*` in a select statement or function /// call argument would expand to. @override List? expansionOfStarColumn; StatementScope(this.parent); @override Iterable get resultSetAvailableToChildScopes { return allAvailableResultSets; } /// All result sets available in this and parent scopes. Iterable get allAvailableResultSets { final here = resultSets.values; return parent.resultSetAvailableToChildScopes.followedBy(here); } @override void addAlias( AstNode origin, ResultSet resultSet, String alias, { bool canUseUnqualifiedColumns = true, }) { final createdAlias = TableAlias(resultSet, alias); resultSets[alias] = ResultSetAvailableInStatement(origin, createdAlias, canUseUnqualifiedColumns: canUseUnqualifiedColumns); } @override void addResolvedResultSet( String? name, ResultSetAvailableInStatement resultSet) { resultSets[name] = resultSet; } @override ResultSetAvailableInStatement? resolveResultSetForReference(String name) { return resultSets[name] ?? parent.resolveResultSetForReference(name); } @override ResultSet? resolveResultSetToAdd(String name) { return additionalKnownTables[name] ?? parent.resolveResultSetToAdd(name); } @override List resolveUnqualifiedReference(String columnName, {bool allowReferenceToResultColumn = false}) { if (allowReferenceToResultColumn) { final foundColumn = namedResultColumns.firstWhereOrNull( (c) => c.name.toLowerCase() == columnName.toLowerCase()); if (foundColumn != null) { return [foundColumn]; } } final available = resultSets.values; final sourceColumns = {}; final availableColumns = []; for (final availableSource in available) { final resolvedColumns = availableSource.resultSet.resultSet?.resolvedColumns; if (resolvedColumns == null || !availableSource.canUseUnqualifiedColumns) { continue; } for (final column in resolvedColumns) { if (column.name.toLowerCase() == columnName.toLowerCase() && sourceColumns.add(column)) { availableColumns.add(AvailableColumn(column, availableSource)); } } } if (availableColumns.isEmpty) { return parent.resolveUnqualifiedReference(columnName); } else { return availableColumns; } } factory StatementScope.forStatement(RootScope root, Statement statement) { return StatementScope(statement.optionalScope ?? root); } static StatementScope cast(ReferenceScope other) { if (other is StatementScope) { return other; } else if (other is MiscStatementSubScope) { return other.parent; } else { throw ArgumentError.value( other, 'other', 'Not resolvable to a statement scope'); } } } /// A special intermediate scope used for nodes that don't see columns and /// tables added to the statement they're in. /// /// An example for this are subqueries appearing in a `FROM` clause, which can't /// see outer columns and tables of the select statement. /// /// Another example is the [InsertStatement.source] of an [InsertStatement], /// which cannot refer to columns of the table being inserted to of course. /// Things like `INSERT INTO tbl (col) VALUES (tbl.col)` are not allowed. class SourceScope extends ReferenceScope with _HasParentScope { final StatementScope enclosingStatement; SourceScope(this.enclosingStatement); @override RootScope get rootScope => enclosingStatement.rootScope; // This scope can't see elements from the enclosing statement, but it can see // elements from grandparents. @override ReferenceScope get _parentScopeForLookups => enclosingStatement.parent; @override ResultSet? resolveResultSetToAdd(String name) { // CTEs from the enclosing statement are also available here return enclosingStatement.resolveResultSetToAdd(name); } } /// A rarely used sub-scope for AST nodes that belong to a statement, but may /// have access to more result sets. /// /// For instance, the body of an `ON CONFLICT DO UPDATE`-clause may refer to a /// table alias `excluded` to get access to a conflicting table. class MiscStatementSubScope extends ReferenceScope with _HasParentScope { final StatementScope parent; @override get _parentScopeForLookups => parent; final Map additionalResultSets = CaseInsensitiveMap(); MiscStatementSubScope(this.parent); @override RootScope get rootScope => parent.rootScope; @override ResultSetAvailableInStatement? resolveResultSetForReference(String name) { return additionalResultSets[name] ?? parent.resolveResultSetForReference(name); } @override void addResolvedResultSet( String? name, ResultSetAvailableInStatement resultSet) { additionalResultSets[name] = resultSet; } } /// A reference scope that only allows a single added result set. /// /// This is used for e.g. foreign key clauses (`REFERENCES table (a, b, c)`), /// where `a`, `b` and `c` can only refer to `table`. class SingleTableReferenceScope extends ReferenceScope { final ReferenceScope parent; final String addedTableName; final ResultSetAvailableInStatement? addedTable; SingleTableReferenceScope(this.parent, this.addedTableName, this.addedTable); @override RootScope get rootScope => parent.rootScope; @override ResultSetAvailableInStatement? resolveResultSetForReference(String name) { if (name == addedTableName) { return addedTable; } else { return null; } } @override List resolveUnqualifiedReference(String columnName, {bool allowReferenceToResultColumn = false}) { final column = addedTable?.resultSet.resultSet?.findColumn(columnName); if (column != null) { return [AvailableColumn(column, addedTable!)]; } else { return const []; } } } lib/src/analysis/schema/column.dart 644 0 0 22324 14612235271 15501 0ustar0 pubpubpart of '../analysis.dart'; /// A column that appears in a [ResultSet]. Has a type and a name. abstract class Column with Referencable, HasMetaMixin implements Typeable, HumanReadable { /// The name of this column in the result set. String get name; /// Whether this column is included in results when running a select query /// like `SELECT * FROM table`. /// /// Some columns, notably the rowid aliases, are exempt from this. bool get includedInResults => true; /// The result set containing this column, or null if this column is not part /// of a known result set. ResultSet? containingSet; @override String humanReadableDescription() { return name; } } /// A column that has a statically known resolved type. abstract interface class ColumnWithType implements Column { /// The type of this column, which is available before any resolution happens /// (we know it from the schema structure). ResolvedType? get type; } /// A column that is part of a table. class TableColumn extends Column implements ColumnWithType { @override final String name; /// Whether this column was created with a `GENERATED ALWAYS AS` column /// constraint. /// /// Generated columns can't be inserted or updated. final bool isGenerated; /// Whether this column is `HIDDEN`, as specified in /// https://www.sqlite.org/vtab.html#hidden_columns_in_virtual_tables final bool isHidden; @override ResultSet? get containingSet => table; @override ResolvedType get type => _type; ResolvedType _type; /// The column constraints set on this column. /// /// This only works columns where [hasDefinition] is true, otherwise this /// getter will throw. The columns in a `CREATE TABLE` statement always have /// a definition, but those from a `CREATE VIRTUAL TABLE` likely don't. /// /// See also: /// - https://www.sqlite.org/syntax/column-constraint.html List get constraints => definition!.constraints; /// The definition in the AST that was used to create this column model. final ColumnDefinition? definition; /// Whether this column has a definition from the ast. bool get hasDefinition => definition != null; /// The table this column belongs to. Table? table; late final bool _isAliasForRowId = _computeIsAliasForRowId(); TableColumn( this.name, this._type, { this.definition, this.isGenerated = false, this.isHidden = false, }); @override bool get includedInResults => !isHidden; /// Applies a type hint to this column. /// /// The [hint] will then be reflected in the [type]. void applyTypeHint(TypeHint hint) { _type = _type.addHint(hint); } /// Whether this column is an alias for the rowid, as defined in /// https://www.sqlite.org/lang_createtable.html#rowid /// /// To summarize, a column is an alias for the rowid if all of the following /// conditions are met: /// - the table has a primary key that consists of exactly one (this) column /// - the column is declared to be an integer /// - if this column has a [PrimaryKeyColumn], the [OrderingMode] of that /// constraint is not [OrderingMode.descending]. bool isAliasForRowId() { return _isAliasForRowId; } bool _computeIsAliasForRowId() { if (definition == null || table == null || type.type != BasicType.int || table!.withoutRowId) { return false; } // We need to check whether this column is a primary key, which could happen // because of a table or a column constraint final columnsWithKey = table!.tableConstraints.whereType(); for (final tableConstraint in columnsWithKey) { if (!tableConstraint.isPrimaryKey) continue; final columns = tableConstraint.columns; if (columns.length != 1) continue; final singleColumnExpr = columns.single.expression; if (singleColumnExpr is Reference && singleColumnExpr.columnName == name) { return true; } } // option 2: This column has a primary key constraint for (final primaryConstraint in constraints.whereType()) { if (primaryConstraint.mode == OrderingMode.descending) return false; // additional restriction: Column type must be exactly "INTEGER" return definition!.typeName == 'INTEGER'; } return false; } @override String humanReadableDescription() { return '$name in ${table!.humanReadableDescription()}'; } } /// A column that is part of a view. class ViewColumn extends Column with DelegatedColumn implements ColumnWithType { final String? _name; @override final ResolvedType? type; @override final Column innerColumn; @override ResultSet? get containingSet => view; /// The view this column belongs to. View? view; /// Creates a view column wrapping a [Column] from the select statement used /// to create the view. /// /// The optional name parameter can be used to override the name for this /// column. By default, the name of the [innerColumn] will be used. ViewColumn(this.innerColumn, this.type, [this._name]); @override String get name => _name ?? super.name; @override String humanReadableDescription() { return '$name in ${view!.humanReadableDescription()}'; } } /// Refers to the special "rowid", "oid" or "_rowid_" column defined for tables /// that weren't created with an `WITHOUT ROWID` clause. class RowId extends TableColumn { // note that such alias is always called "rowid" in the result set - // "SELECT oid FROM table" yields a sinle column called "rowid" RowId() : super('rowid', const ResolvedType(type: BasicType.int)); @override bool get includedInResults => false; } /// A column that is created by an expression. For instance, in the select /// statement "SELECT 1 + 3", there is a column called "1 + 3" of type int. class ExpressionColumn extends Column { @override final String name; /// The expression returned by this column. final Expression expression; /// When drift extensions are enabled and this column was defined with a /// `MAPPED BY` clause, a reference to that clause. final MappedBy? mappedBy; ExpressionColumn({ required this.name, required this.expression, this.mappedBy, }); } /// A column that is created by a reference expression. The difference to an /// [ExpressionColumn] is that the correct case of the column name depends on /// the resolved reference. class ReferenceExpressionColumn extends ExpressionColumn { Reference? get reference => expression as Reference?; @override String get name { return overriddenName ?? reference!.resolvedColumn?.name ?? // The resolved column might not have been resolved yet. Use the // syntactic name from the reference as a fallback: It's only different // for rowid references, and those are easier to resolve. reference!.columnName; } final String? overriddenName; ReferenceExpressionColumn(Reference ref, {this.overriddenName, super.mappedBy}) : super(name: '_', expression: ref); } /// A column that wraps another column. mixin DelegatedColumn on Column { Column? get innerColumn; @override String get name => innerColumn!.name; @override bool get includedInResults => innerColumn?.includedInResults ?? true; } /// The result column of a [CompoundSelectStatement]. class CompoundSelectColumn extends Column with DelegatedColumn { /// The column in [CompoundSelectStatement.base] each of the /// [CompoundSelectStatement.additional] that contributed to this column. final List columns; CompoundSelectColumn(this.columns); @override Column get innerColumn => columns.first; } class CommonTableExpressionColumn extends Column with DelegatedColumn { @override final String name; @override Column? innerColumn; // note that innerColumn is mutable because the column might not be known // during all analysis phases. CommonTableExpressionColumn(this.name, [this.innerColumn]); } /// Result column coming from a `VALUES` select statement. class ValuesSelectColumn extends Column { @override final String name; /// The expressions from a `VALUES` clause contributing to this column. /// /// Essentially, each [ValuesSelectColumn] consists of a column in the values /// of a [ValuesSelectStatement]. final List expressions; ValuesSelectColumn(this.name, this.expressions) : assert(expressions.isNotEmpty); } /// A column that is available in the scope of a statement. /// /// In addition to the [innerColumn], this provides the [source] which brought /// this column into scope. This can be used to determine nullability. class AvailableColumn extends Column with DelegatedColumn { @override final Column innerColumn; final ResultSetAvailableInStatement source; AvailableColumn(this.innerColumn, this.source); } extension UnaliasColumn on Column { /// Attempts to resolve the source of this column, if this is an /// [AvailableColumn] or a [CommonTableExpressionColumn] that refers to /// another column. Column get source { var current = this; while (current is DelegatedColumn) { final inner = current.innerColumn; if (inner != null) { current = inner; } else { return current; } } return current; } } lib/src/analysis/schema/view.dart 644 0 0 1431 14345646642 15145 0ustar0 pubpubpart of '../analysis.dart'; /// A database view. The information stored here will be used to resolve /// references and for type inference. class View extends NamedResultSet with HasMetaMixin implements HumanReadable { @override final String name; @override final List resolvedColumns; /// The ast node that created this view final CreateViewStatement? definition; @override bool get visibleToChildren => true; /// Constructs a view from the known [name] and [resolvedColumns]. View({ required this.name, required this.resolvedColumns, this.definition, }) { for (final column in resolvedColumns) { if (column is ViewColumn) column.view = this; } } @override String humanReadableDescription() { return name; } } lib/src/analysis/schema/from_create_table.dart 644 0 0 16625 14623415614 17653 0ustar0 pubpubpart of '../analysis.dart'; /// Reads the [Table] definition from a [CreateTableStatement]. class SchemaFromCreateTable { /// Whether we should provide additional type hints for nonstandard `BOOL` /// and `DATETIME` columns. final bool driftExtensions; /// Whether the `DATE` column type (only respected if [driftExtensions] are /// enabled) should be reported as a text column instead of an int column. final bool driftUseTextForDateTime; final AnalyzeStatementOptions? statementOptions; const SchemaFromCreateTable({ this.driftExtensions = false, this.driftUseTextForDateTime = false, this.statementOptions, }); /// Reads a [Table] schema from the [stmt] inducing a table (either a /// [CreateTableStatement] or a [CreateVirtualTableStatement]). /// /// This method might throw an exception if the table could not be read. Table read(TableInducingStatement stmt) { if (stmt is CreateTableStatement) { return _readCreateTable(stmt); } else if (stmt is CreateVirtualTableStatement) { final module = stmt.scope.rootScope.knownModules[stmt.moduleName]; if (module == null) { throw CantReadSchemaException('Unknown module "${stmt.moduleName}", ' 'did you register it?'); } return module.parseTable(stmt); } throw AssertionError('Unknown table statement'); } /// Creates a [View] from a [CreateViewStatement]. The `CREATE VIEW` statement /// must be fully resolved through [context] when calling this method. /// /// Example: /// ```dart /// // this will run analysis on the inner select statement and resolve columns /// final ctx = engine.analyze('CREATE VIEW ...'); /// final createViewStmt = ctx.root as CreateViewStatement; /// /// final view = const SchemaFromCreateTable().readView(ctx, createViewStmt); /// ``` View readView(AnalysisContext context, CreateViewStatement stmt) { final columnsFromSelect = stmt.query.resolvedColumns!; final overriddenNames = stmt.columns ?? const []; final viewColumns = []; for (var i = 0; i < columnsFromSelect.length; i++) { final column = columnsFromSelect[i]; // overriddenNames might be shorter than the columns. That's not a valid // CREATE VIEW statement, but we try not to crash. final name = i < overriddenNames.length ? overriddenNames[i] : null; viewColumns.add(ViewColumn(column, context.typeOf(column).type, name)); } return View( name: stmt.viewName, resolvedColumns: viewColumns, definition: stmt, ); } Table _readCreateTable(CreateTableStatement stmt) { final primaryKey = _primaryKeyOf(stmt); return Table( name: stmt.tableName, resolvedColumns: [ for (var def in stmt.columns) _readColumn( def, isStrict: stmt.isStrict, primaryKeyColumnsInStrictTable: stmt.isStrict ? primaryKey : null, ) ], withoutRowId: stmt.withoutRowId, isStrict: stmt.isStrict, tableConstraints: stmt.tableConstraints, definition: stmt, ); } Set _primaryKeyOf(CreateTableStatement stmt) { final columnsInPk = {}; for (final tableConstraint in stmt.tableConstraints.whereType()) { if (tableConstraint.isPrimaryKey) { for (final ref in tableConstraint.columns) { final expr = ref.expression; if (expr is Reference) { columnsInPk.add(expr.columnName); } } } } for (final column in stmt.columns) { for (final constraint in column.constraints) { if (constraint is PrimaryKeyColumn) { columnsInPk.add(column.columnName); } } } return columnsInPk; } TableColumn _readColumn(ColumnDefinition definition, {required bool isStrict, required Set? primaryKeyColumnsInStrictTable}) { final type = resolveColumnType(definition.typeName, isStrict: isStrict); // Column is nullable if it doesn't contain a `NotNull` constraint and it's // not part of a PK in a strict table. final nullable = !definition.constraints.any((c) => c is NotNull) && primaryKeyColumnsInStrictTable?.contains(definition.columnName) != true; final resolvedType = type.withNullable(nullable); return TableColumn( definition.columnName, resolvedType, definition: definition, isGenerated: definition.constraints.any((c) => c is GeneratedAs), ); } /// Resolves a column type via its typename, see the linked rules below. /// Additionally, if [driftExtensions] are enabled, we support [IsBoolean] and /// [IsDateTime] hints if the type name contains `BOOL` or `DATE`, /// respectively. /// https://www.sqlite.org/datatype3.html#determination_of_column_affinity ResolvedType resolveColumnType(String? typeName, {bool isStrict = false}) { if (typeName == null) { return const ResolvedType(type: BasicType.blob); } // S if a custom resolver is installed and yields a type for this column: final custom = statementOptions?.resolveTypeFromText?.call(typeName); if (custom != null) { return custom; } final upper = typeName.toUpperCase(); if (upper.contains('INT')) { if (driftExtensions && upper.contains('INT64')) { return const ResolvedType(type: BasicType.int, hints: [IsBigInt()]); } else { return const ResolvedType(type: BasicType.int); } } if (upper.contains('CHAR') || upper.contains('CLOB') || upper.contains('TEXT')) { return const ResolvedType(type: BasicType.text); } if (upper.contains('BLOB')) { return const ResolvedType(type: BasicType.blob); } if (isStrict && upper == 'ANY') { return const ResolvedType(type: BasicType.any); } if (driftExtensions) { if (upper.contains('BOOL')) { return const ResolvedType.bool(); } if (upper.contains('DATE')) { return ResolvedType( type: driftUseTextForDateTime ? BasicType.text : BasicType.int, hints: const [IsDateTime()], ); } if (upper.contains('ENUMNAME')) { return const ResolvedType(type: BasicType.text); } if (upper.contains('ENUM')) { return const ResolvedType(type: BasicType.int); } } return const ResolvedType(type: BasicType.real); } bool isValidTypeNameForStrictTable(String typeName) { if (driftExtensions) { // Drift_dev will use resolveColumnType to analyze the actual type of the // column, and the generated code will always use a valid type name for // that type. So, anything goes! return true; } else { // See https://www.sqlite.org/stricttables.html const allowed = {'INT', 'INTEGER', 'REAL', 'TEXT', 'BLOB', 'ANY'}; final upper = typeName.toUpperCase(); return allowed.contains(upper); } } /// Looks up the correct column affinity for a declared type name with the /// rules described here: /// https://www.sqlite.org/datatype3.html#determination_of_column_affinity @visibleForTesting BasicType? columnAffinity(String? typeName) => resolveColumnType(typeName).type; } /// Thrown when a table schema could not be read. class CantReadSchemaException implements Exception { final String message; CantReadSchemaException(this.message); @override String toString() { return 'Could not read table schema: $message'; } } lib/src/analysis/context.dart 644 0 0 4465 14345646642 14431 0ustar0 pubpubpart of 'analysis.dart'; /// Result of parsing and analyzing an sql statement. Contains the AST with /// resolved references, information about result columns and errors that were /// reported during analysis. class AnalysisContext { /// All errors that occurred during analysis final List errors = []; /// The root node of the abstract syntax tree final AstNode root; /// The raw sql statement that was used to construct this [AnalysisContext]. final String sql; /// The root scope used when analyzing SQL statements. /// /// This contains information about known tables and modules. final RootScope rootScope; /// Additional information about variables in this context, passed from the /// outside. final AnalyzeStatementOptions stmtOptions; /// Options passed to the surrounding engine. /// /// This contains information about enabled sqlite modules and how to resolve /// some functions. final EngineOptions engineOptions; /// Utilities to read types. final SchemaFromCreateTable schemaSupport; /// New type resolver with better support for nullability and /// complex structures. /// /// By using [TypeInferenceResults.typeOf], the type of an [Expression], /// a [Variable] and [ResultSet.resolvedColumns] may be resolved or inferred. late final TypeInferenceResults types2; /// Constructs a new analysis context from the AST and the source sql. AnalysisContext(this.root, this.sql, this.rootScope, this.engineOptions, {AnalyzeStatementOptions? stmtOptions, required this.schemaSupport}) : stmtOptions = stmtOptions ?? const AnalyzeStatementOptions(); /// Reports an analysis error. void reportError(AnalysisError error) { errors.add(error); } /// Obtains the result of any typeable component. See the information at /// [types2] on important [Typeable]s. ResolveResult typeOf(Typeable t) { final type = types2.typeOf(t); return type != null ? ResolveResult(type) : const ResolveResult.unknown(); } /// Compares two [AstNode]s by their first position in the query. static int compareNodesByOrder(AstNode first, AstNode second) { if (first.first == null || second.first == null) { return 0; // position not set. should we throw in that case? } return first.firstPosition.compareTo(second.firstPosition); } } lib/src/analysis/error.dart 644 0 0 4154 14711507160 14055 0ustar0 pubpubpart of 'analysis.dart'; class AnalysisError { final SyntacticEntity? source; final String? message; final AnalysisErrorType type; AnalysisError._internal(this.type, this.message, this.source); AnalysisError( {required this.type, this.message, SyntacticEntity? relevantNode}) : source = relevantNode; factory AnalysisError.fromParser(ParsingError error) { return AnalysisError._internal( AnalysisErrorType.synctactic, error.message, error.token, ); } /// The relevant portion of the source code that caused this error. Some AST /// nodes don't have a span, in that case this error is going to have a null /// span as well. FileSpan? get span => source?.span; @override String toString() { final msgSpan = span; if (msgSpan != null) { return msgSpan.message(message ?? type.toString(), color: true); } else { return 'Error: $type: $message at $source'; } } } class UnresolvedReferenceError extends AnalysisError { /// The attempted reference that couldn't be resolved final String reference; /// A list of alternative references that would be available for [reference]. final Iterable available; UnresolvedReferenceError( {required super.type, required this.reference, required this.available, AstNode? super.relevantNode}); @override String get message { return 'Could not find $reference. Available are: ${available.join(', ')}'; } } enum AnalysisErrorType { allColumnsAreGenerated, duplicatePrimaryKeyDeclaration, writeToGeneratedColumn, referencedUnknownTable, referencedUnknownColumn, ambiguousReference, synctactic, unknownFunction, invalidAmountOfParameters, starColumnWithoutTable, compoundColumnCountMismatch, cteColumnCountMismatch, circularReference, valuesSelectCountMismatch, viewColumnNamesMismatch, rowValueMisuse, notSupportedInDesiredVersion, illegalUseOfReturning, raiseMisuse, missingPrimaryKey, noTypeNameInStrictTable, invalidTypeNameInStrictTable, invalidTriggerMode, distinctAggregateWithWrongParameterCount, other, hint, } lib/src/analysis/analysis.dart 644 0 0 2057 14606250400 14542 0ustar0 pubpubimport 'dart:math' show max; import 'package:collection/collection.dart' show IterableExtension; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; // hiding because of http://dartbug.com/39263 import 'package:sqlparser/sqlparser.dart' hide ExpandParameters; import 'package:sqlparser/src/utils/meta.dart'; import '../../utils/case_insensitive_map.dart'; export 'types/data.dart'; export 'types/types.dart' show TypeInferenceResults; part 'context.dart'; part 'error.dart'; part 'options.dart'; part 'schema/column.dart'; part 'schema/from_create_table.dart'; part 'schema/references.dart'; part 'schema/result_set.dart'; part 'schema/table.dart'; part 'schema/view.dart'; part 'steps/column_resolver.dart'; part 'steps/linting_visitor.dart'; part 'steps/prepare_ast.dart'; part 'steps/reference_resolver.dart'; part 'steps/set_parent_visitor.dart'; part 'utils/expand_function_parameters.dart'; /// Something that can be represented in a human-readable description. abstract class HumanReadable { String humanReadableDescription(); } lib/src/analysis/types 755 0 0 0 0 12550 5ustar0 pubpublib/src/analysis/types/graph 755 0 0 0 0 13651 5ustar0 pubpublib/src/analysis/types/graph/relationships.dart 644 0 0 5315 14612235271 20056 0ustar0 pubpubpart of '../types.dart'; /// Dependency declaring that [target] is nullable if any in [from] is /// nullable. class NullableIfSomeOtherIs extends TypeRelation implements MultiSourceRelation { @override final Typeable target; @override final List from; NullableIfSomeOtherIs(this.target, this.from); } /// Dependency declaring that [target] has exactly the same type as [other]. class CopyTypeFrom extends TypeRelation implements DirectedRelation { @override final Typeable target; final Typeable other; /// When true, [target] will be the array-variant of [other]. When false, /// [target] will be the scalar variant of [other]. When null, nothing will be /// transformed. final bool? array; /// Whether [target] is the nullable version of [other]. final bool makeNullable; CopyTypeFrom(this.target, this.other, {this.array, this.makeNullable = false}); } /// Dependency declaring that [target] has a type that matches all of [from]. class CopyEncapsulating extends TypeRelation implements MultiSourceRelation { @override final Typeable target; @override final List from; final CastMode? cast; final EncapsulatingNullability nullability; CopyEncapsulating(this.target, this.from, [this.cast, this.nullability = EncapsulatingNullability.nullIfAny]); } /// Dependency declaring that [elements] all have the same type. This is /// an optional dependency that will only be applied when one type is known and /// the others are not. class HaveSameType extends TypeRelation { final List elements; HaveSameType(this.elements); Iterable getOthers(Typeable t) { assert(elements.contains(t)); return elements.where((e) => e != t); } } /// Dependency declaring that, if no better option is found, [target] should /// have the specified [defaultType]. class DefaultType extends TypeRelation implements DirectedRelation { @override final Typeable target; final ResolvedType? defaultType; final bool? isNullable; DefaultType(this.target, {this.defaultType, this.isNullable}); } enum CastMode { numeric, /// Like [numeric], but assume [BasicType.int] if the resulting type doesn't /// match. numericPreferInt, boolean, } enum EncapsulatingNullability { nullIfAny, nullIfAll, } /// Dependency declaring that [target] has the same type as [other] after /// casting it with [cast]. class CopyAndCast extends TypeRelation implements DirectedRelation { @override final Typeable target; final Typeable other; final CastMode cast; final bool dropTypeHint; final bool makeNullable; CopyAndCast( this.target, this.other, this.cast, { this.dropTypeHint = false, this.makeNullable = false, }); } lib/src/analysis/types/graph/type_graph.dart 644 0 0 23030 14720702252 17344 0ustar0 pubpubpart of '../types.dart'; class TypeGraph { final _ResolvedVariables _variables = _ResolvedVariables(); final Map _knownTypes = {}; final Map _knownNullability = {}; final List _relations = []; final Map> _edges = {}; final Set _candidateForLaxMultiPropagation = {}; final List _defaultTypes = []; ResolvedType? operator [](Typeable t) { final normalized = _variables.normalize(t); return _lookupWithoutNormalization(normalized); } ResolvedType? _lookupWithoutNormalization(Typeable t) { if (_knownTypes.containsKey(t)) { final type = _knownTypes[t]; final nullability = _knownNullability[t]; if (nullability != null) { return type!.withNullable(nullability); } return type; } return null; } void operator []=(Typeable t, ResolvedType type) { final normalized = _variables.normalize(t); _knownTypes[normalized] = type; if (type.nullable != null && !_knownNullability.containsKey(normalized)) { // nullability is known _knownNullability[normalized] = type.nullable; } } bool knowsType(Typeable t) => _knownTypes.containsKey(_variables.normalize(t)); bool knowsNullability(Typeable t) { final normalized = _variables.normalize(t); final knownType = _knownTypes[normalized]; return (knownType != null && knownType.nullable != null) || _knownNullability.containsKey(normalized); } void addRelation(TypeRelation relation) { _relations.add(relation); } void markNullability(Typeable t, bool isNullable) { _knownNullability[_variables.normalize(t)] = isNullable; } void performResolve() { _indexRelations(); var queue = List.of(_knownTypes.keys); // Apply type propagation to known types for which we know the nullability // too first. queue.sortBy((e) => _knownNullability.containsKey(e) ? 1 : 0); while (queue.isNotEmpty) { _propagateTypeInfo(queue, queue.removeLast()); } // propagate many-to-one sources where we don't know each source type, but // some of them. queue = List.of(_candidateForLaxMultiPropagation); while (queue.isNotEmpty) { _propagateTypeInfo(queue, queue.removeLast(), laxMultiSourcePropagation: true); } // apply default types for (final applyDefault in _defaultTypes) { final target = applyDefault.target; final type = applyDefault.defaultType; if (type != null && !knowsType(target)) { this[target] = applyDefault.defaultType!; } final nullability = applyDefault.isNullable; if (nullability != null && _knownNullability.containsKey(target)) { markNullability(target, nullability); } } } void _propagateTypeInfo(List resolved, Typeable t, {bool laxMultiSourcePropagation = false}) { if (!_edges.containsKey(t)) return; // propagate changes for (final edge in _edges[t]!) { if (edge is CopyTypeFrom) { var type = this[edge.other]; if (edge.array != null) { type = type!.toArray(edge.array); } if (edge.makeNullable) { _knownNullability[edge.target] = true; } _copyType(resolved, edge.other, edge.target, type); } else if (edge is HaveSameType) { for (final other in edge.getOthers(t)) { _copyType(resolved, t, other); } } else if (edge is CopyAndCast) { var copied = this[t]!.cast(edge.cast, edge.dropTypeHint); if (edge.makeNullable) { copied = copied.withNullable(true); } _copyType(resolved, t, edge.target, copied); } else if (edge is MultiSourceRelation) { // handle many-to-one changes, if all targets have been resolved or // lax handling is enabled. if (laxMultiSourcePropagation || edge.from.every(knowsType)) { _propagateManyToOne(edge, resolved); _candidateForLaxMultiPropagation.removeAll(edge.from); } else { _candidateForLaxMultiPropagation.add(t); } } } } void _propagateManyToOne(MultiSourceRelation edge, List resolved) { if (edge is CopyEncapsulating) { if (!knowsType(edge.target)) { final fromTypes = edge.from.map((t) => this[t]).where((e) => e != null); var encapsulated = _encapsulate(fromTypes, edge.nullability); if (encapsulated != null) { if (edge.cast != null) { encapsulated = encapsulated.cast(edge.cast!, false); } this[edge.target] = encapsulated; resolved.add(edge.target); } } } else if (edge is NullableIfSomeOtherIs && !_knownNullability.containsKey(edge.target)) { final nullable = edge.from .map((e) => _knownNullability[e]) .any((nullable) => nullable == true); _knownNullability[edge.target] = nullable; resolved.add(edge.target); } } void _copyType(List resolved, Typeable from, Typeable to, [ResolvedType? type]) { // if the target hasn't been resolved yet, copy the current type and // visit the target later if (!knowsType(to)) { this[to] = type ?? this[from]!; resolved.add(to); } } ResolvedType? _encapsulate( Iterable targets, EncapsulatingNullability nullability) { return targets.fold(null, (previous, element) { if (previous == null) return element; final previousType = previous.type; final elementType = element!.type; bool nullableTogether; switch (nullability) { case EncapsulatingNullability.nullIfAny: nullableTogether = previous.nullable == true || element.nullable == true; break; case EncapsulatingNullability.nullIfAll: nullableTogether = previous.nullable == true && element.nullable == true; break; } if (previousType == elementType || elementType == BasicType.nullType) { return previous.withNullable(nullableTogether); } if (previousType == BasicType.nullType) { return element.withNullable(nullableTogether); } bool isIntOrNumeric(BasicType? type) { return type == BasicType.int || type == BasicType.real; } // encapsulate two different numeric types to real if (isIntOrNumeric(previousType) && isIntOrNumeric(elementType)) { return ResolvedType(type: BasicType.real, nullable: nullableTogether); } // fallback to text if everything else fails return const ResolvedType(type: BasicType.text); }); } void _indexRelations() { _edges.clear(); void put(Typeable t, TypeRelation r) { _edges.putIfAbsent(t, () => []).add(r); } void putAll(MultiSourceRelation r) { for (final element in r.from) { put(element, r); } } for (final relation in _relations) { if (relation is NullableIfSomeOtherIs) { putAll(relation); } else if (relation is CopyTypeFrom) { put(relation.other, relation); } else if (relation is CopyEncapsulating) { putAll(relation); } else if (relation is HaveSameType) { for (final element in relation.elements) { put(element, relation); } } else if (relation is DefaultType) { _defaultTypes.add(relation); } else if (relation is CopyAndCast) { put(relation.other, relation); } else { throw AssertionError('Unknown type relation: $relation'); } } } } /// Describes how the type of different [Typeable] instances has an effect on /// others. /// /// Note that all logic is handled in the type graph, these are logic-less model /// classes only. abstract class TypeRelation {} /// Relation that only has an effect on one [Typeable] -- namely, [target]. abstract class DirectedRelation implements TypeRelation { /// The only [Typeable] effected by this relation. Typeable get target; } /// Relation where the type of multiple [Typeable] instances must be known. abstract class MultiSourceRelation implements DirectedRelation { List get from; } /// Keeps track of resolved variable types so that they can be re-used. /// Different [Variable] instances can refer to the same logical sql variable, /// so we keep track of them. class _ResolvedVariables { final Map _referenceForIndex = {}; Typeable normalize(Typeable t) { if (t is! Variable) return t; final normalized = t; final index = normalized.resolvedIndex; if (index != null) { return _referenceForIndex[index] ??= normalized; } else { return t; } } Typeable? referenceForIndex(int resolvedVariableIndex) { return _referenceForIndex[resolvedVariableIndex]; } } extension ResolvedTypeUtils on ResolvedType { ResolvedType cast(CastMode mode, bool dropTypeHint) { switch (mode) { case CastMode.numeric: case CastMode.numericPreferInt: if (type == BasicType.int || type == BasicType.real) { if (dropTypeHint && hints.isNotEmpty) { return ResolvedType( type: type, hints: const [], nullable: nullable, isArray: isArray, ); } else { return this; } } return mode == CastMode.numeric ? const ResolvedType(type: BasicType.real) : const ResolvedType(type: BasicType.int); case CastMode.boolean: return const ResolvedType.bool(); } } } lib/src/analysis/types/types.dart 644 0 0 4423 14720702252 15232 0ustar0 pubpubimport 'dart:math'; import 'package:collection/collection.dart'; import 'package:sqlparser/sqlparser.dart'; part 'expectation.dart'; part 'graph/relationships.dart'; part 'graph/type_graph.dart'; part 'resolving_visitor.dart'; /// Contains all information associated to a single type inference pass. class TypeInferenceSession { final TypeGraph graph = TypeGraph(); final EngineOptions options; final AnalysisContext context; TypeInferenceResults? results; TypeInferenceSession(this.context, [EngineOptions? options]) : options = options ?? EngineOptions() { results = TypeInferenceResults._(this); } void _markTypeResolved(Typeable t, ResolvedType r) { graph[t] = r; } void _checkAndResolve( Typeable t, ResolvedType r, TypeExpectation expectation) { if (expectation is ExactTypeExpectation) { final expectedType = expectation.type; if (expectedType.hints.isNotEmpty && r.hints.isEmpty && expectedType.type == r.type) { r = r.copyWith(hints: expectedType.hints); } } _markTypeResolved(t, r); } /// Returns the inferred type of [t], or `null` if it couldn't be inferred. ResolvedType? typeOf(Typeable t) { return graph[t]; } ResolvedType? typeOfVariable(int index) { final reference = graph._variables.referenceForIndex(index); if (reference != null) { return graph._lookupWithoutNormalization(reference); } else { return null; } } void _addRelation(TypeRelation relationship) { graph.addRelation(relationship); } /// This is not currently implemented. void _hintNullability(Typeable t, bool nullable) { graph.markNullability(t, nullable); } /// Asks the underlying [TypeGraph] to propagate known types via known /// [TypeRelation]s. /// /// The [SqlEngine] will call this method when analyzing a statement. There's /// no need to call it from user code. void _finish() { graph.performResolve(); } } /// Apis to view results of a type inference session. class TypeInferenceResults { final TypeInferenceSession session; TypeInferenceResults._(this.session); /// Finds the resolved type of [t], or `null` if the type of [t] could not /// be inferred. ResolvedType? typeOf(Typeable t) { return session.typeOf(t); } } lib/src/analysis/types/join_analysis.dart 644 0 0 11477 14612235271 16761 0ustar0 pubpubimport '../../ast/ast.dart'; import '../analysis.dart'; /// Tracks table references that must be non-nullable in a query row. /// /// This is used to determine the nullability of column references. For /// instance, consider the following query: /// /// ```sql /// SELECT foo.x, bar.y FROM foo /// LEFT OUTER JOIN bar ON ... /// ``` /// /// Clearly, `foo.x` is non-nullable in the result if `x` is a non-nullable /// column in `foo`. We can't say the same thing about `bar.y` though: Even if /// the column is declared to be `NOT NULL`, `bar` might be nullable in this /// query. /// /// A [JoinModel] is attached to each basic [SelectStatement]. You can obtain /// the model for any ast node via [JoinModel.of]. It will lookup the model from /// the enclosing [SelectStatement], if there is one. /// /// If a [Reference] refers to a table that's in [JoinModel.nonNullable] and /// the resolved column is non-nullable, we can assume that the reference is /// going to be non-nullable too. /// /// At the moment, we consider the following tables to be /// [JoinModel.nonNullable]: /// - the "primary" table of a select statement (`foo` in the example above) /// - inner, cross, regular (no keyword, comma) joins /// /// In the future, we'll also consider foreign key constraints. class JoinModel { final List nonNullable; JoinModel._(this.nonNullable); factory JoinModel._resolve(AstNode statement) { final visitor = _FindNonNullableJoins(); statement.accept(visitor, true); return JoinModel._(visitor.nonNullable); } static JoinModel? of(AstNode node) { final enclosingStatement = node.enclosingOfType(); if (enclosingStatement == null) return null; final existing = enclosingStatement.meta(); if (existing != null) return existing; final created = JoinModel._resolve(enclosingStatement); enclosingStatement.setMeta(created); return created; } /// Computes whether the element the [reference] is pointing to is nullable /// from the perspective of this join model. /// /// This does not include the computed nullability of what the reference is /// referring to, just whether the reference points to a table that may not /// be present because it comes from an outer join. bool? referenceIsNullable(Reference reference) { final resolved = reference.resolvedColumn; if (resolved is AvailableColumn) { return availableColumnIsNullable(resolved); } final resultSet = reference.resultEntity; // ignore: avoid_returning_null if (resultSet == null) return null; return !nonNullable.contains(resultSet); } /// Returns whether an [AvailableColumn] is nullable from the perspective of /// this join model by checking whether it comes from an outer join. bool availableColumnIsNullable(AvailableColumn column) { return !nonNullable.contains(column.source); } /// Checks whether the result set is nullable in the surrounding select /// statement. bool isNullableTable(ResultSet resultSet) { return nonNullable.every((nonNullableRef) { return nonNullableRef.resultSet.resultSet != resultSet; }); } } // The boolean arg indicates whether a visited queryable is needed for the // result to have any rows (which, in particular, means its non-nullable) class _FindNonNullableJoins extends RecursiveVisitor { final List nonNullable = []; void _addIfMakesResultStatementAvailable(TableOrSubquery node) { final resultSet = node.availableResultSet; if (resultSet != null) nonNullable.add(resultSet); } @override void visitSelectStatement(SelectStatement e, bool arg) { visitNullable(e.from, true); } @override void visitDeleteStatement(DeleteStatement e, bool arg) { visit(e.table, true); } @override void visitInsertStatement(InsertStatement e, bool arg) { visit(e.table, true); } @override void visitUpdateStatement(UpdateStatement e, bool arg) { visit(e.table, true); visitNullable(e.from, true); } @override void visitJoinClause(JoinClause e, bool arg) { if (!arg) return; visit(e.primary, true); for (final additional in e.joins) { final operator = additional.operator; if (operator.operator != JoinOperatorKind.left && operator.operator != JoinOperatorKind.right && operator.operator != JoinOperatorKind.full) { visit(additional, true); } } } @override void visitTableReference(TableReference e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } @override void visitTableValuedFunction(TableValuedFunction e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } } lib/src/analysis/types/expectation.dart 644 0 0 6013 14354027251 16410 0ustar0 pubpubpart of 'types.dart'; /// Contains expectations on the type that a [Typeable] might have. /// /// Different instances of this class are passed along when descending into the /// AST during type analysis. For instance, logical binary expressions might /// expect that their operands are logical expressions as well. This model /// also allows us to construct more complicated relationships. For instance, /// we can express the expected column types for a `INSERT INTO SELECT` /// statement. abstract class TypeExpectation { const TypeExpectation(); int get specificity => 0; /// Returns the expectaction from `this` or [other] with a higher specificity. TypeExpectation orMoreSpecific(TypeExpectation other) { if (specificity > other.specificity) { return this; } else { return other; } } } /// Passed along when an ast node makes no assumption on the type of its /// child nodes. class NoTypeExpectation extends TypeExpectation { const NoTypeExpectation(); } /// Passed down when a node must have a known type. class ExactTypeExpectation extends TypeExpectation { /// The type we expect the child nodes to have. final ResolvedType type; /// Whether the child node max have another type than [type]. /// /// When false, we can report a compile-time error for a type mismatch. final bool lax; @override int get specificity => lax ? 50 : 100; const ExactTypeExpectation._(this.type, this.lax); const ExactTypeExpectation(this.type) : lax = false; const ExactTypeExpectation.laxly(this.type) : lax = true; } /// Passed down when the general type must match (e.g. "numeric), but the /// exact type is unknown. /// /// This makes no expectation on nullability. class RoughTypeExpectation extends TypeExpectation { final _RoughType _type; const RoughTypeExpectation._(this._type); const RoughTypeExpectation.numeric() : this._(_RoughType.numeric); @override int get specificity => 10; bool accepts(ResolvedType type) { final baseType = type.type; switch (_type) { case _RoughType.numeric: return baseType == BasicType.int || baseType == BasicType.real; } } ResolvedType defaultType() { switch (_type) { case _RoughType.numeric: return const ResolvedType(type: BasicType.real); } } } enum _RoughType { numeric, } /// Type expectation for result columns in a select statement. /// /// This can be used to set expectations in an `INSERT INTO SELECT` statement, /// where the column types are constrained by what's expected in the insert /// statement. class SelectTypeExpectation extends TypeExpectation { final List columnExpectations; SelectTypeExpectation(this.columnExpectations); } extension on TypeExpectation { TypeExpectation clearArray() { if (this is ExactTypeExpectation) { final expectation = this as ExactTypeExpectation; if (expectation.type.isArray) { return ExactTypeExpectation._( expectation.type.toArray(false), expectation.lax); } } return this; } } lib/src/analysis/types/data.dart 644 0 0 13401 14656673450 15032 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; /// Something that has a type. abstract class Typeable {} /// A type that sql expressions can have at runtime. enum BasicType { nullType, int, real, text, blob, /// A column that has explicitly been defined as `ANY` in a strict table. /// /// This is semantically different from a column with an unknown type, which /// is why we don't currently use [any] as a fallback during type inference. any, } class ResolvedType { static const _hintEquality = ListEquality(); final BasicType? type; /// We set hints for additional information that might be useful for /// applications but aren't covered by just exposing a [BasicType]. See the /// comment on [TypeHint] for examples. final List hints; /// Whether this type is nullable. A `null` value for [nullable] indicates /// that nullability is unknown. final bool? nullable; /// Whether this type is an array. final bool isArray; const ResolvedType( {this.type, this.hints = const [], this.nullable = false, this.isArray = false}); const ResolvedType.bool({bool? nullable = false}) : this( type: BasicType.int, hints: const [IsBoolean()], nullable: nullable); ResolvedType get withoutNullabilityInfo { return nullable == null ? this : ResolvedType( type: type, hints: hints, isArray: isArray, nullable: null); } ResolvedType withNullable(bool nullable) { return nullable == this.nullable ? this : copyWith(nullable: nullable); } ResolvedType toArray(bool? array) { return copyWith(isArray: array); } ResolvedType copyWith( {List? hints, bool? nullable, bool? isArray}) { return ResolvedType( type: type, hints: hints ?? this.hints, nullable: nullable ?? this.nullable, isArray: isArray ?? this.isArray, ); } T? hint() { return hints.whereType().firstOrNull; } ResolvedType addHint(TypeHint hint) { return copyWith(hints: [...hints, hint]); } @override bool operator ==(Object other) { return identical(this, other) || other is ResolvedType && other.type == type && _hintEquality.equals(other.hints, hints) && other.nullable == nullable && other.isArray == isArray; } @override int get hashCode { return type.hashCode + _hintEquality.hash(hints) + nullable.hashCode; } @override String toString() { return 'ResolvedType($type, hints: $hints, nullable: $nullable, ' 'array: $isArray)'; } } /// Provides more precise hints than the [BasicType]. For instance, booleans are /// stored as ints in sqlite, but it might be desirable to know whether an /// expression will actually be a boolean, so we could set the /// [ResolvedType.hint] to [IsBoolean]. abstract class TypeHint { const TypeHint(); @override int get hashCode => runtimeType.hashCode; @override bool operator ==(Object other) => other.runtimeType == runtimeType; } /// Type hint to mark that this type will contain a boolean value. class IsBoolean extends TypeHint { const IsBoolean(); } /// Type hint to mark that this type will contain a date time value. class IsDateTime extends TypeHint { const IsDateTime(); } /// A type hint to mark that this type might contain a large integer that should /// be mapped to Dart as a [BigInt]. class IsBigInt extends TypeHint { const IsBigInt(); } /// This could be a `blob` or `text` depending on the context /// https://www.sqlite.org/geopoly.html class IsGeopolyPolygon extends TypeHint { const IsGeopolyPolygon(); } /// Result of resolving a type. This can either have the resolved [type] set, /// or it can inform the called that it [needsContext] to resolve the type /// properly. Failure to resolve the type will have the [unknown] flag set. /// /// When you see a [ResolveResult] that is unknown or needs context in the /// final AST returned by [SqlEngine.analyze], assume that the type cannot be /// determined. class ResolveResult { /// The resolved type. final ResolvedType? type; /// Whether more context is needed to resolve the type. Used internally by the /// analyzer. final bool needsContext; /// Whether type resolution failed. final bool unknown; const ResolveResult(this.type) : needsContext = false, unknown = false; const ResolveResult.needsContext() : type = null, needsContext = true, unknown = false; const ResolveResult.unknown() : type = null, needsContext = false, unknown = true; bool get nullable => type?.nullable ?? true; ResolveResult mapResult(ResolvedType Function(ResolvedType?) map) { if (type != null) { return ResolveResult(map(type)); } else if (needsContext) { return const ResolveResult.needsContext(); } else { return const ResolveResult.unknown(); } } /// Copies the result with the [nullable] information, if there is one. If /// there isn't, the failure state will be copied into the new /// [ResolveResult]. ResolveResult withNullable(bool nullable) { return mapResult((r) => r!.withNullable(nullable)); } @override bool operator ==(Object other) { return identical(this, other) || other is ResolveResult && other.type == type && other.needsContext == needsContext && other.unknown == unknown; } @override int get hashCode => type.hashCode + needsContext.hashCode + unknown.hashCode; @override String toString() { if (type != null) { return 'ResolveResult: $type'; } else { return 'ResolveResult(needsContext: $needsContext, unknown: $unknown)'; } } } lib/src/analysis/types/resolving_visitor.dart 644 0 0 75071 14720132410 17675 0ustar0 pubpubpart of 'types.dart'; const _intType = ResolvedType(type: BasicType.int); const _realType = ResolvedType(type: BasicType.real); const _textType = ResolvedType(type: BasicType.text); const _expectCondition = ExactTypeExpectation.laxly(ResolvedType.bool()); const _expectInt = ExactTypeExpectation.laxly(_intType); const _expectNum = RoughTypeExpectation.numeric(); const _expectString = ExactTypeExpectation.laxly(_textType); class TypeResolver extends RecursiveVisitor { final TypeInferenceSession session; final Set _handledColumns = {}; TypeResolver(this.session); void run(AstNode root) { visit(root, const NoTypeExpectation()); // annotate Columns as well. They implement Typeable, but aren't an ast // node, which means this visitor doesn't find them root.acceptWithoutArg(_ResultColumnVisitor(this)); session._finish(); } @override void visitSelectStatement(SelectStatement e, TypeExpectation arg) { _handleWhereClause(e); visitBaseSelectStatement(e, arg); } @override void visitBaseSelectStatement(BaseSelectStatement stmt, TypeExpectation arg) { var currentColumnIndex = 0; final columnExpectations = arg is SelectTypeExpectation ? arg.columnExpectations : const []; final whereClause = stmt is SelectStatement ? stmt.where : null; for (final child in stmt.childNodes) { if (child == whereClause) continue; // handled in visitSelectStatement if (child is ResultColumn) { if (child is ExpressionResultColumn) { final expectation = currentColumnIndex < columnExpectations.length ? columnExpectations[currentColumnIndex] : const NoTypeExpectation(); visit(child, expectation); currentColumnIndex++; } else if (child is StarResultColumn) { currentColumnIndex += child.scope.expansionOfStarColumn?.length ?? 1; } else if (child is NestedQueryColumn) { visit(child.select, arg); } else if (child is NestedStarResultColumn) { final columns = child.resultSet?.resolvedColumns; if (columns != null) { for (final column in columns) { _handleColumn(column, child); } } } } else { visit(child, arg); } } } @override void visitSubQuery(SubQuery e, TypeExpectation arg) { // The query should return one column only, but this is not the right place // to lint that. Just pick any column and resolve to that. final columnsOfQuery = e.select.resolvedColumns!; if (columnsOfQuery.isEmpty) { return super.visitSubQuery(e, arg); } // The returned column is nullable (since it could be that the subquery does // not resolve to any row) if the expression is not an aggregate function. // Aggregate functions with `GROUP BY` subqueries can also be nullable if // no groups exist. final columnForExpr = columnsOfQuery.first; final hasAggregate = switch (columnForExpr.source) { ExpressionColumn(:final expression) => _HasAggregateSubExpressions().visit(expression, null) ?? false, _ => false, }; final hasGroupBy = switch (e.select) { final SelectStatement select => select.groupBy != null, _ => false, }; final makeNullable = hasGroupBy || !hasAggregate; session._addRelation( CopyTypeFrom(e, columnForExpr, makeNullable: makeNullable)); visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, TypeExpectation arg) { if (e.withClause != null) visit(e.withClause!, arg); visitList(e.targetColumns, const NoTypeExpectation()); final targets = e.resolvedTargetColumns ?? const []; for (final column in targets) { _handleColumn(column, e); } final expectations = targets.map((r) { if (r != null && session.graph.knowsType(r)) { return ExactTypeExpectation(session.typeOf(r)!); } return const NoTypeExpectation(); }).toList(); visit(e.source, SelectTypeExpectation(expectations)); visitNullable(e.upsert, const NoTypeExpectation()); visitNullable(e.returning, const NoTypeExpectation()); } @override void visitCrudStatement(CrudStatement stmt, TypeExpectation arg) { if (stmt is StatementWithWhere) { final typedStmt = stmt as StatementWithWhere; _handleWhereClause(typedStmt); visitExcept(stmt, typedStmt.where, arg); } else { visitChildren(stmt, arg); } } @override void visitCreateIndexStatement(CreateIndexStatement e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } @override void visitJoin(Join e, TypeExpectation arg) { final constraint = e.constraint; if (constraint is OnConstraint) { // ON , should be boolean visit(constraint.expression, const ExactTypeExpectation.laxly(ResolvedType.bool())); visitExcept(e, constraint.expression, arg); } else { visitChildren(e, arg); } } @override void visitSingleColumnSetComponent( SingleColumnSetComponent e, TypeExpectation arg) { visit(e.column, const NoTypeExpectation()); _lazyCopy(e.expression, e.column); visit(e.expression, const NoTypeExpectation()); } @override void visitMultiColumnSetComponent( MultiColumnSetComponent e, TypeExpectation arg) { visitList(e.columns, const NoTypeExpectation()); final targets = e.resolvedTargetColumns ?? const []; for (final column in targets) { _handleColumn(column, e); } final expectations = targets.map((r) { if (r != null && session.graph.knowsType(r)) { return ExactTypeExpectation(session.typeOf(r)!); } return const NoTypeExpectation(); }).toList(); visit(e.rowValue, SelectTypeExpectation(expectations)); } @override void visitGroupBy(GroupBy e, TypeExpectation arg) { visitList(e.by, const NoTypeExpectation()); visitNullable(e.having, _expectCondition); } @override void visitLimit(Limit e, TypeExpectation arg) { visit(e.count, _expectInt); visitNullable(e.offset, _expectInt); } @override void visitFrameSpec(FrameSpec e, TypeExpectation arg) { // handle something like "RANGE BETWEEN ? PRECEDING AND ? FOLLOWING if (e.start.isExpressionOffset) { visit(e.start.offset!, _expectInt); } if (e.end.isExpressionOffset) { visit(e.end.offset!, _expectInt); } } @override void defaultLiteral(Literal e, TypeExpectation arg) { late ResolvedType type; var nullable = false; if (e is NullLiteral) { type = const ResolvedType(type: BasicType.nullType, nullable: true); nullable = true; } else if (e is StringLiteral) { type = e.isBinary ? const ResolvedType(type: BasicType.blob) : _textType; } else if (e is BooleanLiteral) { type = const ResolvedType.bool(); } else if (e is NumericLiteral) { type = e.isInt ? _intType : _realType; } else if (e is TimeConstantLiteral) { type = _textType; } session._hintNullability(e, nullable); session._checkAndResolve(e, type, arg); } @override void visitVariable(Variable e, TypeExpectation arg) { _inferAsVariable(e, arg); } @override void visitDriftSpecificNode(DriftSpecificNode e, TypeExpectation arg) { if (e is DartExpressionPlaceholder) { _inferAsVariable(e, arg); } else { super.visitDriftSpecificNode(e, arg); } } void _inferAsVariable(Expression e, TypeExpectation arg) { ResolvedType? resolved; if (e is Variable) { resolved = session.context.stmtOptions.specifiedTypeOf(e); } resolved ??= _inferFromContext(arg); if (resolved != null) { session._checkAndResolve(e, resolved, arg); } else if (arg is RoughTypeExpectation) { session._addRelation(DefaultType(e, defaultType: arg.defaultType())); } visitChildren(e, arg); } @override void visitCollateExpression(CollateExpression e, TypeExpectation arg) { session._checkAndResolve(e, _textType, arg); visit(e.inner, _expectString); } @override void visitColumnDefinition(ColumnDefinition e, TypeExpectation arg) { // If we're analyzing a `CREATE TABLE` statement, we might know this colum's // type. final createTable = e.parent; if (createTable is CreateTableStatement) { final resolvedTable = session.context.rootScope.knownTables[createTable.tableName]; final resolvedColumn = resolvedTable?.findColumn(e.columnName); if (resolvedColumn is ColumnWithType) { final type = resolvedColumn.type; if (type != null) { // Make sure we have compatible types in the constraints visitList(e.constraints, ExactTypeExpectation(type)); return; } } } super.visitColumnDefinition(e, arg); } @override void visitExists(ExistsExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); visit(e.select, const NoTypeExpectation()); } @override void visitUnaryExpression(UnaryExpression e, TypeExpectation arg) { final operatorType = e.operator.type; if (operatorType == TokenType.plus) { // plus is a no-op, so copy type from child session._addRelation(CopyTypeFrom(e, e.inner)); visit(e.inner, arg); } else if (operatorType == TokenType.not) { // unary not expression - boolean, but nullability depends on child node. session._checkAndResolve(e, const ResolvedType.bool(nullable: null), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.inner])); visit(e.inner, const ExactTypeExpectation.laxly(ResolvedType.bool())); } else if (operatorType == TokenType.minus) { // unary minus - can be int or real depending on child node session._addRelation(CopyAndCast(e, e.inner, CastMode.numeric)); visit(e.inner, arg.orMoreSpecific(const RoughTypeExpectation.numeric())); } else if (operatorType == TokenType.tilde) { // bitwise negation - definitely int, but nullability depends on child session._checkAndResolve( e, const ResolvedType(type: BasicType.int, nullable: null), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.inner])); visit(e.inner, const NoTypeExpectation()); } else { throw StateError( 'Unary operator $operatorType not recognized by types2. At $e'); } } @override void visitTuple(Tuple e, TypeExpectation arg) { if (arg is SelectTypeExpectation) { // We have a specific type requirement for each entry, let's use that final expectations = arg.columnExpectations; for (var i = 0; i < e.expressions.length; i++) { final expectation = i < expectations.length ? expectations[i] : const NoTypeExpectation(); visit(e.expressions[i], expectation); } } else { // Assume that this tuple forms an array, and clear the array expectation // for children. final expectationForChildren = arg.clearArray(); visitChildren(e, expectationForChildren); // make children non-arrays for (final child in e.childNodes) { session._addRelation(CopyTypeFrom(child, e, array: false)); } } } @override void visitBetweenExpression(BetweenExpression e, TypeExpectation arg) { visitChildren(e, _expectNum); session .._checkAndResolve(e, const ResolvedType.bool(), arg) .._addRelation(NullableIfSomeOtherIs(e, e.childNodes)) .._addRelation(HaveSameType([e.lower, e.upper, e.check])); } @override void visitBinaryExpression(BinaryExpression e, TypeExpectation arg) { switch (e.operator.type) { case TokenType.and: case TokenType.or: session._checkAndResolve(e, const ResolvedType.bool(), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); // logic expressions, so children must be boolean visitChildren(e, const ExactTypeExpectation.laxly(ResolvedType.bool())); break; case TokenType.equal: case TokenType.doubleEqual: case TokenType.exclamationEqual: case TokenType.lessMore: case TokenType.less: case TokenType.lessEqual: case TokenType.more: case TokenType.moreEqual: // comparison. Returns bool, copying nullability from children. session._checkAndResolve(e, const ResolvedType.bool(), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); // Not technically a requirement, but assume lhs and rhs have the same // type. session._addRelation(HaveSameType([e.left, e.right])); visitChildren(e, const NoTypeExpectation()); break; case TokenType.plus: case TokenType.minus: case TokenType.star: case TokenType.slash: session._addRelation( CopyEncapsulating(e, [e.left, e.right], CastMode.numericPreferInt)); visitChildren(e, const RoughTypeExpectation.numeric()); break; // all of those only really make sense for integers case TokenType.shiftLeft: case TokenType.shiftRight: case TokenType.pipe: case TokenType.ampersand: case TokenType.percent: const type = ResolvedType(type: BasicType.int); session._checkAndResolve(e, type, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); visitChildren(e, const ExactTypeExpectation.laxly(type)); break; case TokenType.doublePipe: // string concatenation. session._checkAndResolve(e, _textType.withoutNullabilityInfo, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); const childExpectation = ExactTypeExpectation.laxly(_textType); visit(e.left, childExpectation); visit(e.right, childExpectation); break; case TokenType.dashRangle: // Extract as JSON, this takes two strings and returns a string (or // `NULL` if the value wasn't found). session._checkAndResolve(e, _textType.withNullable(true), arg); visit(e.left, _expectString); visit(e.right, _expectString); break; case TokenType.dashRangleRangle: // Extract as JSON to SQL value. session._hintNullability(e, true); visit(e.left, _expectString); visit(e.right, _expectString); break; default: throw StateError('Binary operator ${e.operator.type} not recognized ' 'by types2. At $e'); } } @override void visitIsExpression(IsExpression e, TypeExpectation arg) { session .._checkAndResolve(e, const ResolvedType.bool(), arg) .._addRelation(HaveSameType([e.left, e.right])) .._hintNullability(e, false); visitChildren(e, const NoTypeExpectation()); } @override void visitIsNullExpression(IsNullExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); session._hintNullability(e, false); visitChildren(e, const NoTypeExpectation()); } @override void visitInExpression(InExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); if (e.inside case Expression inExpr) { session._addRelation(NullableIfSomeOtherIs(e, [e.left, inExpr])); session._addRelation(CopyTypeFrom(inExpr, e.left, array: true)); } visitChildren(e, const NoTypeExpectation()); } @override void visitCaseExpression(CaseExpression e, TypeExpectation arg) { session._addRelation(CopyEncapsulating(e, [ for (final when in e.whens) when.then, if (e.elseExpr != null) e.elseExpr!, ])); if (e.base != null) { session._addRelation( CopyEncapsulating(e.base!, [for (final when in e.whens) when.when]), ); } visitNullable(e.base, const NoTypeExpectation()); visitExcept(e, e.base, arg); } @override void visitWhen(WhenComponent e, TypeExpectation arg) { final parent = e.parent; if (parent is CaseExpression && parent.base != null) { // case expressions with base -> condition is compared to base session._addRelation(CopyTypeFrom(e.when, parent.base!)); visit(e.when, const NoTypeExpectation()); } else { // case expression without base -> the conditions are booleans visit(e.when, const ExactTypeExpectation(ResolvedType.bool())); } visit(e.then, arg); } @override void visitCastExpression(CastExpression e, TypeExpectation arg) { final type = session.context.schemaSupport.resolveColumnType(e.typeName); session._checkAndResolve(e, type.withoutNullabilityInfo, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.operand])); visit(e.operand, const NoTypeExpectation()); } @override void visitStarFunctionParameter( StarFunctionParameter e, TypeExpectation arg) { final available = e.scope.expansionOfStarColumn; if (available != null) { // Make sure we resolve these columns, the type of some function // invocation could depend on it. for (final column in available) { _handleColumn(column, e); } } } @override void visitStringComparison( StringComparisonExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType(type: BasicType.text), arg); session._addRelation(NullableIfSomeOtherIs( e, [ e.left, e.right, if (e.escape != null) e.escape!, ], )); visit(e.left, _expectString); visit(e.right, _expectString); visitNullable(e.escape, _expectString); } @override void visitParentheses(Parentheses e, TypeExpectation arg) { session._addRelation(CopyTypeFrom(e, e.expression)); visit(e.expression, arg); } @override void visitReference(Reference e, TypeExpectation arg) { final resolved = e.resolvedColumn; if (resolved == null) return; _handleColumn(resolved, e); _lazyCopy(e, resolved); } @override void visitExpressionInvocation(ExpressionInvocation e, TypeExpectation arg) { final result = _resolveInvocation(e); if (result.type case final resolvedType?) { session._checkAndResolve(e, resolvedType, arg); } else if (arg case ExactTypeExpectation(type: final expectedType) when result.needsContext) { // Use expected type when we need more context session._checkAndResolve(e, expectedType, arg); } final visited = _resolveFunctionArguments(e); for (final child in e.childNodes) { if (!visited.contains(child)) { visit(child, const NoTypeExpectation()); } } } FunctionHandler? _functionHandlerFor(ExpressionInvocation e) { return session.options.addedFunctions[e.name.toLowerCase()]; } ResolveResult _resolveInvocation(ExpressionInvocation e) { final params = e.expandParameters(); final builtInResult = _resolveBuiltInFunction(e, params); if (builtInResult != null) { return builtInResult; } final extensionHandler = _functionHandlerFor(e); if (extensionHandler != null) { return extensionHandler.inferReturnType(session.context, e, params); } session.context.reportError(AnalysisError( type: AnalysisErrorType.unknownFunction, message: 'Function ${e.name} could not be found', relevantNode: e.nameToken ?? e, )); return ResolveResult.unknown(); } ResolveResult? _resolveBuiltInFunction( ExpressionInvocation e, List params) { void nullableIfChildIs() { session._addRelation(NullableIfSomeOtherIs(e, params)); } void checkArgumentCount(int expectedArgs) { if (params.length != expectedArgs) { session.context.reportError(AnalysisError( type: AnalysisErrorType.invalidAmountOfParameters, message: '${e.name} expects $expectedArgs arguments, got ${params.length}.', relevantNode: e.parameters, )); } } final lowercaseName = e.name.toLowerCase(); switch (lowercaseName) { case 'round': nullableIfChildIs(); //if there is only one params, it rounds to int. Otherwise real if (params.length == 1) { return ResolveResult(_intType); } else { return ResolveResult(_realType); } // ignore: dead_code throw AssertionError(); // required so that this switch compiles case 'sum': checkArgumentCount(1); // The result of `sum()` is `NULL` if there are no input rows. session._addRelation(CopyAndCast( e, params.first, CastMode.numeric, dropTypeHint: true, makeNullable: true, )); session._addRelation( DefaultType(e, defaultType: _realType.withNullable(true))); return const ResolveResult.needsContext(); case 'lower': case 'ltrim': case 'printf': case 'format': case 'replace': case 'rtrim': case 'substr': case 'trim': case 'upper': nullableIfChildIs(); return ResolveResult(_textType.withoutNullabilityInfo); case 'concat': return ResolveResult(_textType); case 'concat_ws': // null if the first argument is null if (params.isNotEmpty) { session._addRelation(NullableIfSomeOtherIs(e, [params.first])); } return ResolveResult(_textType.withoutNullabilityInfo); case 'group_concat': case 'string_agg': return ResolveResult(_textType.withNullable(true)); case 'date': case 'time': case 'julianday': case 'strftime': case 'char': case 'hex': case 'quote': case 'soundex': case 'sqlite_compileoption_set': case 'sqlite_version': case 'typeof': case 'timediff': return ResolveResult(_textType); case 'datetime': return ResolveResult( _textType.copyWith(hints: const [IsDateTime()], nullable: true), ); case 'changes': case 'last_insert_rowid': case 'random': case 'sqlite_compileoption_used': case 'total_changes': case 'count': case 'row_number': case 'rank': case 'dense_rank': case 'ntile': case 'octet_length': return ResolveResult(_intType); case 'instr': case 'length': case 'unicode': nullableIfChildIs(); return ResolveResult(_intType); case 'randomblob': case 'zeroblob': return const ResolveResult(ResolvedType(type: BasicType.blob)); case 'unhex': return const ResolveResult( ResolvedType(type: BasicType.blob, nullable: true)); case 'avg': return ResolveResult(_realType.withNullable(true)); case 'total': case 'percent_rank': case 'cume_dist': return ResolveResult(_realType); case 'abs': case 'likelihood': case 'likely': case 'unlikely': session._addRelation(CopyTypeFrom(e, params.first)); return const ResolveResult.needsContext(); case 'iif': checkArgumentCount(3); if (params.length == 3) { // IIF(a, b, c) is essentially CASE WHEN a THEN b ELSE c END final cases = [params[1], params[2]]; session .._addRelation(CopyEncapsulating(e, cases)) .._addRelation(HaveSameType(cases)); } return const ResolveResult.needsContext(); case 'coalesce': case 'ifnull': session._addRelation(CopyEncapsulating( e, params, null, EncapsulatingNullability.nullIfAll)); for (final param in params) { session._addRelation(DefaultType(param, isNullable: true)); } return const ResolveResult.needsContext(); case 'nullif': session._hintNullability(e, true); session._addRelation(CopyTypeFrom(e, params.first)); return const ResolveResult.needsContext(); case 'first_value': case 'last_value': case 'lag': case 'lead': case 'nth_value': session._addRelation(CopyTypeFrom(e, params.first)); return const ResolveResult.needsContext(); case 'max': case 'min': session._hintNullability(e, true); session .._addRelation(CopyEncapsulating(e, params)) .._addRelation(HaveSameType(params)); return const ResolveResult.needsContext(); case 'unixepoch': return const ResolveResult( ResolvedType( type: BasicType.int, nullable: true, hints: [IsDateTime()], ), ); } return null; } Set _resolveFunctionArguments(SqlInvocation e) { final params = e.expandParameters(); final visited = {}; final name = e.name.toLowerCase(); switch (name) { case 'iif': if (params.isNotEmpty) { final condition = params[0]; if (condition is Expression) { visited.add(condition); visit(condition, _expectCondition); } } break; case 'nth_value': if (params.length >= 2 && params[1] is Expression) { // the second argument of nth_value is always an integer final secondParam = params[1] as Expression; visit(secondParam, _expectInt); visited.add(secondParam); } break; case 'unhex': for (var i = 0; i < min(2, params.length); i++) { final param = params[i]; if (param is Expression) { visit(param, _expectString); visited.add(param); } } case 'timediff': for (var i = 0; i < min(2, params.length); i++) { final param = params[i]; if (param is Expression) { visit( param, const ExactTypeExpectation(ResolvedType( type: BasicType.text, hints: [IsDateTime()], ))); visited.add(param); } } break; } final extensionHandler = e is ExpressionInvocation ? _functionHandlerFor(e) : null; if (extensionHandler != null) { for (final arg in params) { if (arg is! Expression) continue; final expressionArgument = arg; final result = extensionHandler.inferArgumentType( session.context, e, expressionArgument); final type = result.type; if (type != null) { session._markTypeResolved(expressionArgument, type); } visited.add(expressionArgument); } } return visited; } @override void visitUpsertClauseEntry(UpsertClauseEntry e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } @override void visitDoUpdate(DoUpdate e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } void _handleColumn(Column? column, [AstNode? context]) { if (column == null || session.graph.knowsType(column) || _handledColumns.contains(column)) { return; } _handledColumns.add(column); if (column is ColumnWithType) { session._markTypeResolved(column, column.type!); } else if (column is ExpressionColumn) { _lazyCopy(column, column.expression); } else if (column is CompoundSelectColumn) { session._addRelation(CopyEncapsulating(column, column.columns)); column.columns.forEach(_handleColumn); } else if (column is ValuesSelectColumn) { session._addRelation(CopyEncapsulating(column, column.expressions)); } else if (column is DelegatedColumn && column.innerColumn != null) { _handleColumn(column.innerColumn); var makeNullable = false; if (column is AvailableColumn) { // The nullability depends on whether the column was introduced in an // outer join. final model = context != null ? JoinModel.of(context) : null; makeNullable = model != null && model.availableColumnIsNullable(column); } _lazyCopy(column, column.innerColumn, makeNullable: makeNullable); } } void _lazyCopy(Typeable to, Typeable? from, {bool makeNullable = false}) { if (from == null) return; if (session.graph.knowsType(from)) { var type = session.typeOf(from)!; if (makeNullable) { type = type.withNullable(true); session._markTypeResolved(to, type); } else if (session.graph.knowsNullability(from)) { session._markTypeResolved(to, type); } else { session._markTypeResolved(to, type); session._addRelation(NullableIfSomeOtherIs(to, [from])); } } else { session._addRelation(CopyTypeFrom(to, from, makeNullable: makeNullable)); } } void _handleWhereClause(HasWhereClause e) { if (e.where != null) { // assume that a where statement is a boolean expression. Sqlite // internally casts (https://www.sqlite.org/lang_expr.html#booleanexpr), // so be lax visit(e.where!, _expectCondition); } } ResolvedType? _inferFromContext(TypeExpectation expectation) { if (expectation is ExactTypeExpectation) { return expectation.type; } return null; } } class _ResultColumnVisitor extends RecursiveVisitor { final TypeResolver resolver; _ResultColumnVisitor(this.resolver); @override void visitBaseSelectStatement(BaseSelectStatement stmt, void arg) { if (stmt.resolvedColumns != null) { for (final column in stmt.resolvedColumns!) { resolver._handleColumn(column, stmt); } } visitChildren(stmt, arg); } void _handleReturning(StatementReturningColumns stmt) { final columns = stmt.returnedResultSet?.resolvedColumns; if (columns != null) { for (final column in columns) { resolver._handleColumn(column, stmt); } } } @override void visitInsertStatement(InsertStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } @override void visitDeleteStatement(DeleteStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } } /// Visitor that returns true if any of the expressions visited is an aggregate /// invocation expression. class _HasAggregateSubExpressions extends RecursiveVisitor { @override bool? defaultNode(AstNode e, void arg) { for (final child in e.childNodes) { final result = visit(child, arg); if (result != null) { return result; } } return null; } @override bool? visitExpressionInvocation(ExpressionInvocation e, void arg) { if (e.isAggregate) { return true; } // Don't return false if not aggregate, an argument could be an aggregate // function. return defaultNode(e, arg); } } lib/src/analysis/utils 755 0 0 0 0 12544 5ustar0 pubpublib/src/analysis/utils/expand_function_parameters.dart 644 0 0 2536 14345646642 21511 0ustar0 pubpubpart of '../analysis.dart'; /// Extension to expand parameters defined in a sql invocation, which is either /// a [FunctionExpression] or an [AggregateFunctionInvocation]. extension ExpandParameters on SqlInvocation { /// Returns the expanded parameters of a function call. /// /// When a [StarFunctionParameter] is used, it's expanded to the /// [ReferenceScope.expansionOfStarColumn]. /// Elements of the result are either an [Expression] or a [Column]. List expandParameters() { final sqlParameters = parameters; if (sqlParameters is ExprFunctionParameters) { return sqlParameters.parameters; } else if (sqlParameters is StarFunctionParameter) { // if * is used as a parameter, it refers to all columns in all tables // that are available in the current scope. final allColumns = scope.expansionOfStarColumn; if (allColumns == null) return const []; // When we look at `SELECT SUM(*), foo FROM ...`, the star in `SUM` // shouldn't expand to include itself. final unrelated = allColumns.where((column) { if (column is! ExpressionColumn) return true; final expression = column.expression; return !expression.selfAndDescendants.contains(this); }); return unrelated.toList(); } throw ArgumentError('Unknown parameters: $sqlParameters'); } } lib/src/analysis/options.dart 644 0 0 2453 14370670576 14434 0ustar0 pubpubpart of 'analysis.dart'; /// Signature of a function that resolves the type of a SQL type literal. typedef TypeFromText = ResolvedType? Function(String); /// Options to analyze a sql statement. This can be used if the type of a /// variable is known from the outside. class AnalyzeStatementOptions { final Map indexedVariableTypes; final Map namedVariableTypes; /// Drift specific. Maps from a Dart placeholder in a query to its default /// expression, if set. final Map defaultValuesForPlaceholder; final TypeFromText? resolveTypeFromText; const AnalyzeStatementOptions({ this.indexedVariableTypes = const {}, this.namedVariableTypes = const {}, this.defaultValuesForPlaceholder = const {}, this.resolveTypeFromText, }); /// Looks up the defined type for that variable. /// /// Returns null if the type of that variable hasn't been set. ResolvedType? specifiedTypeOf(Variable variable) { // colon-named variables also have an index! final index = variable.resolvedIndex; if (index != null && indexedVariableTypes.containsKey(index)) { return indexedVariableTypes[index]; } else if (variable is ColonNamedVariable) { return namedVariableTypes[variable.name]; } return null; } } lib/utils 755 0 0 0 0 10132 5ustar0 pubpublib/utils/node_to_text.dart 644 0 0 106241 14711507160 14205 0ustar0 pubpub/// Library to convert AST nodes back to text. /// /// See the [NodeToText] extension for details. library utils.node_to_text; import 'package:charcode/charcode.dart'; import 'package:sqlparser/sqlparser.dart'; class NodeSqlBuilder extends AstVisitor { final StringSink buffer; /// Whether we need to insert a space before writing the next identifier. bool needsSpace = false; NodeSqlBuilder([StringSink? buffer]) : buffer = buffer ?? StringBuffer(); /// Writes a space character if [needsSpace] is set. /// /// This also resets [needsSpace] to `false`. void spaceIfNeeded() { if (needsSpace) { needsSpace = false; _space(); } } bool isKeyword(String lexeme) { return isKeywordLexeme(lexeme); } String escapeIdentifier(String identifier) { return '"$identifier"'; } @override void visitAggregateFunctionInvocation( AggregateFunctionInvocation e, void arg) { symbol(e.name, spaceBefore: true); symbol('('); visit(e.parameters, arg); visitNullable(e.orderBy, arg); symbol(')'); if (e.filter != null) { keyword(TokenType.filter); symbol('(', spaceBefore: true); keyword(TokenType.where); visit(e.filter!, arg); symbol(')', spaceAfter: true); } } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { visitAggregateFunctionInvocation(e, arg); if (e.windowDefinition != null) { keyword(TokenType.over); visit(e.windowDefinition!, arg); } else if (e.windowName != null) { keyword(TokenType.over); identifier(e.windowName!); } } @override void visitBeginTransaction(BeginTransactionStatement e, void arg) { keyword(TokenType.begin); switch (e.mode) { case TransactionMode.none: break; case TransactionMode.deferred: keyword(TokenType.deferred); break; case TransactionMode.immediate: keyword(TokenType.immediate); break; case TransactionMode.exclusive: keyword(TokenType.exclusive); break; } } @override void visitBetweenExpression(BetweenExpression e, void arg) { visit(e.check, arg); if (e.not) { keyword(TokenType.not); } keyword(TokenType.between); visit(e.lower, arg); keyword(TokenType.and); visit(e.upper, arg); } @override void visitBinaryExpression(BinaryExpression e, void arg) { visit(e.left, arg); final operatorSymbol = const { TokenType.doublePipe: '||', TokenType.star: '*', TokenType.slash: '/', TokenType.percent: '%', TokenType.plus: '+', TokenType.minus: '-', TokenType.shiftLeft: '<<', TokenType.shiftRight: '>>', TokenType.ampersand: '&', TokenType.pipe: '|', TokenType.less: '<', TokenType.lessEqual: '<=', TokenType.more: '>', TokenType.moreEqual: '>=', TokenType.equal: '=', TokenType.doubleEqual: '==', TokenType.exclamationEqual: '!=', TokenType.lessMore: '<>', TokenType.dashRangle: '->', TokenType.dashRangleRangle: '->>', }[e.operator.type]; if (operatorSymbol != null) { symbol(operatorSymbol, spaceBefore: true, spaceAfter: true); } else { keyword(e.operator.type); } visit(e.right, arg); } void _writeStatements(Iterable statements) { for (final stmt in statements) { visit(stmt, null); symbol(';'); } } @override void visitBlock(Block block, void arg) { keyword(TokenType.begin); _writeStatements(block.statements); keyword(TokenType.end); } @override void visitBooleanLiteral(BooleanLiteral e, void arg) { keyword(e.value ? TokenType.$true : TokenType.$false); } @override void visitCaseExpression(CaseExpression e, void arg) { keyword(TokenType.$case); visitNullable(e.base, arg); visitList(e.whens, arg); final elseExpr = e.elseExpr; if (elseExpr != null) { keyword(TokenType.$else); visit(elseExpr, arg); } keyword(TokenType.end); } @override void visitCastExpression(CastExpression e, void arg) { keyword(TokenType.cast); symbol('('); visit(e.operand, arg); keyword(TokenType.as); symbol(e.typeName, spaceBefore: true); symbol(')', spaceAfter: true); } @override void visitCollateExpression(CollateExpression e, void arg) { visit(e.inner, arg); keyword(TokenType.collate); identifier(e.collation); } @override void visitColumnConstraint(ColumnConstraint e, void arg) { if (e.name != null) { keyword(TokenType.constraint); identifier(e.name!); } e.when( primaryKey: (primaryKey) { keyword(TokenType.primary); keyword(TokenType.key); _orderingMode(primaryKey.mode); _conflictClause(primaryKey.onConflict); if (primaryKey.autoIncrement) keyword(TokenType.autoincrement); }, notNull: (notNull) { keyword(TokenType.not); keyword(TokenType.$null); _conflictClause(notNull.onConflict); }, nullable: (nullable) { keyword(TokenType.$null); }, unique: (unique) { keyword(TokenType.unique); _conflictClause(unique.onConflict); }, check: (check) { keyword(TokenType.check); symbol('(', spaceBefore: true); visit(check.expression, arg); symbol(')', spaceAfter: true); }, isDefault: (def) { keyword(TokenType.$default); final expr = def.expression; if (expr is Literal) { visit(expr, arg); } else { symbol('(', spaceBefore: true); visit(expr, arg); symbol(')', spaceAfter: true); } }, collate: (collate) { keyword(TokenType.collate); identifier(collate.collation); }, foreignKey: (foreignKey) { visit(foreignKey.clause, arg); }, generatedAs: (generatedAs) { keyword(TokenType.generated); keyword(TokenType.always); keyword(TokenType.as); symbol('(', spaceBefore: true); visit(generatedAs.expression, arg); symbol(')', spaceAfter: true); if (generatedAs.stored) { keyword(TokenType.stored); } else { keyword(TokenType.virtual); } }, mappedBy: (mappedBy) { keyword(TokenType.mapped); keyword(TokenType.by); dartCode(mappedBy.mapper.dartCode); }, ); } @override void visitColumnDefinition(ColumnDefinition e, void arg) { identifier(e.columnName); if (e.typeName != null) { symbol(e.typeName!, spaceAfter: true, spaceBefore: true); } visitList(e.constraints, arg); } @override void visitCommitStatement(CommitStatement e, void arg) { keyword(TokenType.commit); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { identifier(e.cteTableName); if (e.columnNames != null) { symbol('(', spaceBefore: true); var first = true; for (final columnName in e.columnNames!) { if (!first) { symbol(',', spaceAfter: true); } identifier(columnName, spaceBefore: !first, spaceAfter: false); first = false; } symbol(')', spaceAfter: true); } keyword(TokenType.as); switch (e.materializationHint) { case MaterializationHint.notMaterialized: keyword(TokenType.not); keyword(TokenType.materialized); break; case MaterializationHint.materialized: keyword(TokenType.materialized); break; case null: break; } symbol('(', spaceBefore: true); visit(e.as, arg); symbol(')', spaceAfter: true); } @override void visitCompoundSelectPart(CompoundSelectPart e, void arg) { switch (e.mode) { case CompoundSelectMode.union: keyword(TokenType.union); break; case CompoundSelectMode.unionAll: keyword(TokenType.union); keyword(TokenType.all); break; case CompoundSelectMode.intersect: keyword(TokenType.intersect); break; case CompoundSelectMode.except: keyword(TokenType.except); break; } visit(e.select, arg); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { visitNullable(e.withClause, arg); visit(e.base, arg); visitList(e.additional, arg); } @override void visitCreateIndexStatement(CreateIndexStatement e, void arg) { keyword(TokenType.create); if (e.unique) { keyword(TokenType.unique); } keyword(TokenType.$index); _ifNotExists(e.ifNotExists); identifier(e.indexName); keyword(TokenType.on); visit(e.on, arg); symbol('(', spaceBefore: true); _join(e.columns, ','); symbol(')', spaceAfter: true); _where(e.where); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { keyword(TokenType.create); keyword(TokenType.table); _ifNotExists(e.ifNotExists); identifier(e.tableName); symbol('('); _join([...e.columns, ...e.tableConstraints], ','); symbol(')'); if (e.withoutRowId) { keyword(TokenType.without); keyword(TokenType.rowid); } if (e.isStrict) { if (e.withoutRowId) symbol(','); keyword(TokenType.strict); } e.driftTableName?.accept(this, arg); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { keyword(TokenType.create); keyword(TokenType.trigger); _ifNotExists(e.ifNotExists); identifier(e.triggerName); switch (e.mode) { case TriggerMode.before: keyword(TokenType.before); break; case TriggerMode.after: keyword(TokenType.after); break; case TriggerMode.insteadOf: keyword(TokenType.instead); keyword(TokenType.of); break; } visit(e.target, arg); keyword(TokenType.on); visit(e.onTable, arg); if (e.when != null) { keyword(TokenType.when); visit(e.when!, arg); } visit(e.action, arg); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { keyword(TokenType.create); keyword(TokenType.view); _ifNotExists(e.ifNotExists); identifier(e.viewName); e.driftTableName?.accept(this, arg); if (e.columns != null) { symbol('(', spaceBefore: true); symbol(e.columns!.join(',')); symbol(')', spaceAfter: true); } keyword(TokenType.as); visit(e.query, arg); } @override void visitCreateVirtualTableStatement( CreateVirtualTableStatement e, void arg) { keyword(TokenType.create); keyword(TokenType.virtual); keyword(TokenType.table); _ifNotExists(e.ifNotExists); identifier(e.tableName); keyword(TokenType.using); identifier(e.moduleName); symbol('(${e.argumentContent.join(', ')})'); } @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is DartPlaceholder) { e.when( isLimit: (_) => keyword(TokenType.limit), isOrderBy: (_) { keyword(TokenType.order); keyword(TokenType.by); }, ); symbol(r'$', spaceBefore: true); symbol(e.name, spaceAfter: true); } else if (e is DeclaredStatement) { identifier(e.identifier.name); if (e.parameters.isNotEmpty) { symbol('('); _join(e.parameters, ','); symbol(')'); } visitNullable(e.as, arg); symbol(':', spaceAfter: true); visit(e.statement, arg); symbol(';'); } else if (e is DriftFile) { for (final stmt in e.statements) { visit(stmt, arg); buffer.write('\n'); needsSpace = false; } } else if (e is ImportStatement) { keyword(TokenType.import); _stringLiteral(e.importedFile); symbol(';', spaceAfter: true); } else if (e is StatementParameter) { if (e is VariableTypeHint) { if (e.isRequired) keyword(TokenType.required); visit(e.variable, arg); final typeName = e.typeName; if (typeName != null) { keyword(TokenType.as); symbol(typeName, spaceBefore: true, spaceAfter: true); } if (e.orNull) { keyword(TokenType.or); keyword(TokenType.$null); } } else if (e is DartPlaceholderDefaultValue) { symbol('\$${e.variableName}', spaceAfter: true); symbol('=', spaceBefore: true, spaceAfter: true); visit(e.defaultValue, arg); } else { throw AssertionError('Unknown StatementParameter: $e'); } } else if (e is DriftTableName) { keyword(e.useExistingDartClass ? TokenType.$with : TokenType.as); identifier(e.overriddenDataClassName); final constructor = e.constructorName; if (constructor != null) { symbol('.'); identifier(constructor); } } else if (e is NestedStarResultColumn) { identifier(e.tableName); symbol('.**', spaceAfter: true); } else if (e is NestedQueryColumn) { symbol('LIST(', spaceBefore: true); visit(e.select, arg); symbol(')', spaceAfter: true); if (e.as != null) { keyword(TokenType.as); identifier(e.as!); } } else if (e is TransactionBlock) { visit(e.begin, arg); _writeStatements(e.innerStatements); visit(e.commit, arg); } } @override void visitDefaultValues(DefaultValues e, void arg) { keyword(TokenType.$default); keyword(TokenType.$values); } @override void visitDeferrableClause(DeferrableClause e, void arg) { if (e.not) { keyword(TokenType.not); } keyword(TokenType.deferrable); switch (e.declaredInitially) { case InitialDeferrableMode.deferred: keyword(TokenType.initially); keyword(TokenType.deferred); break; case InitialDeferrableMode.immediate: keyword(TokenType.initially); keyword(TokenType.immediate); break; default: // declaredInitially == null, don't do anything break; } } @override void visitDeleteStatement(DeleteStatement e, void arg) { visitNullable(e.withClause, arg); keyword(TokenType.delete); _from(e.from); _where(e.where); visitNullable(e.returning, arg); } @override void visitDeleteTriggerTarget(DeleteTarget e, void arg) { keyword(TokenType.delete); } @override void visitDoNothing(DoNothing e, void arg) { keyword(TokenType.nothing); } @override void visitDoUpdate(DoUpdate e, void arg) { keyword(TokenType.update); keyword(TokenType.set); _join(e.set, ','); _where(e.where); } @override void visitExists(ExistsExpression e, void arg) { keyword(TokenType.exists); symbol('(', spaceBefore: true); visit(e.select, null); symbol(')', spaceAfter: true); } @override void visitExpressionFunctionParameters(ExprFunctionParameters e, void arg) { if (e.distinct) { keyword(TokenType.distinct); } _join(e.parameters, ','); } @override void visitExpressionResultColumn(ExpressionResultColumn e, void arg) { visit(e.expression, arg); visitNullable(e.mappedBy, arg); if (e.as != null) { keyword(TokenType.as); identifier(e.as!); } } @override void visitForeignKeyClause(ForeignKeyClause e, void arg) { keyword(TokenType.references); visit(e.foreignTable, arg); if (e.columnNames.isNotEmpty) { symbol('('); _join(e.columnNames, ','); symbol(')'); } void referenceAction(ReferenceAction action) { switch (action) { case ReferenceAction.setNull: keyword(TokenType.set); keyword(TokenType.$null); break; case ReferenceAction.setDefault: keyword(TokenType.set); keyword(TokenType.$default); break; case ReferenceAction.cascade: keyword(TokenType.cascade); break; case ReferenceAction.restrict: keyword(TokenType.restrict); break; case ReferenceAction.noAction: keyword(TokenType.no); keyword(TokenType.action); break; } } if (e.onUpdate != null) { keyword(TokenType.on); keyword(TokenType.update); referenceAction(e.onUpdate!); } if (e.onDelete != null) { keyword(TokenType.on); keyword(TokenType.delete); referenceAction(e.onDelete!); } visitNullable(e.deferrable, arg); } @override void visitFrameSpec(FrameSpec e, void arg) { void frameBoundary(FrameBoundary boundary) { void precedingOrFollowing(bool preceding) { if (boundary.isUnbounded) { keyword(TokenType.unbounded); } else { visit(boundary.offset!, arg); } keyword(preceding ? TokenType.preceding : TokenType.following); } if (boundary.isCurrentRow) { keyword(TokenType.current); keyword(TokenType.row); } else if (boundary.preceding) { precedingOrFollowing(true); } else { precedingOrFollowing(false); } } keyword(const { FrameType.range: TokenType.range, FrameType.rows: TokenType.rows, FrameType.groups: TokenType.groups, }[e.type!]!); keyword(TokenType.between); frameBoundary(e.start); keyword(TokenType.and); frameBoundary(e.end); if (e.excludeMode != null) { keyword(TokenType.exclude); switch (e.excludeMode!) { case ExcludeMode.noOthers: keyword(TokenType.no); keyword(TokenType.others); break; case ExcludeMode.currentRow: keyword(TokenType.current); keyword(TokenType.row); break; case ExcludeMode.group: keyword(TokenType.group); break; case ExcludeMode.ties: keyword(TokenType.ties); break; } } } @override void visitFunction(FunctionExpression e, void arg) { identifier(e.name); symbol('('); visit(e.parameters, arg); symbol(')', spaceAfter: true); } @override void visitGroupBy(GroupBy e, void arg) { keyword(TokenType.group); keyword(TokenType.by); _join(e.by, ','); if (e.having != null) { keyword(TokenType.having); visit(e.having!, arg); } } @override void visitIndexedColumn(IndexedColumn e, void arg) { visit(e.expression, arg); _orderingMode(e.ordering); } @override void visitInExpression(InExpression e, void arg) { visit(e.left, arg); if (e.not) { keyword(TokenType.not); } keyword(TokenType.$in); visit(e.inside, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { visitNullable(e.withClause, arg); final mode = e.mode; if (mode == InsertMode.insert) { keyword(TokenType.insert); } else if (mode == InsertMode.replace) { keyword(TokenType.replace); } else { keyword(TokenType.insert); keyword(TokenType.or); keyword(const { InsertMode.insertOrReplace: TokenType.replace, InsertMode.insertOrRollback: TokenType.rollback, InsertMode.insertOrAbort: TokenType.abort, InsertMode.insertOrFail: TokenType.fail, InsertMode.insertOrIgnore: TokenType.ignore, }[mode]!); } keyword(TokenType.into); visit(e.table, arg); if (e.targetColumns.isNotEmpty) { symbol('(', spaceBefore: true); _join(e.targetColumns, ','); symbol(')', spaceAfter: true); } visit(e.source, arg); visitNullable(e.upsert, arg); visitNullable(e.returning, arg); } @override void visitInsertTriggerTarget(InsertTarget e, void arg) { keyword(TokenType.insert); } @override void visitInvalidStatement(InvalidStatement e, void arg) { throw UnsupportedError( 'InvalidStatement does not have a textual representation'); } @override void visitIsExpression(IsExpression e, void arg) { visit(e.left, arg); keyword(TokenType.$is); // Avoid writing `DISTINCT FROM`, but be aware that it effectively negates // the generated `IS` again. final negated = e.negated ^ e.distinctFromSyntax; if (negated) { keyword(TokenType.not); } visit(e.right, arg); } @override void visitIsNullExpression(IsNullExpression e, void arg) { visit(e.operand, arg); if (e.negated) { keyword(TokenType.notNull); } else { keyword(TokenType.isNull); } } @override void visitJoin(Join e, void arg) { visit(e.operator, null); visit(e.query, null); final constraint = e.constraint; if (constraint is OnConstraint) { keyword(TokenType.on); visit(constraint.expression, arg); } else if (constraint is UsingConstraint) { keyword(TokenType.using); symbol('(${constraint.columnNames.join(', ')})'); } } @override void visitJoinOperator(JoinOperator e, void arg) { if (e.operator == JoinOperatorKind.comma) { symbol(','); } else { if (e.natural) { keyword(TokenType.natural); } switch (e.operator) { case JoinOperatorKind.none: break; case JoinOperatorKind.comma: throw AssertionError("Can't happen"); case JoinOperatorKind.left: keyword(TokenType.left); break; case JoinOperatorKind.right: keyword(TokenType.right); break; case JoinOperatorKind.full: keyword(TokenType.full); break; case JoinOperatorKind.inner: keyword(TokenType.inner); break; case JoinOperatorKind.cross: keyword(TokenType.cross); break; } if (e.outer) { keyword(TokenType.outer); } keyword(TokenType.join); } } @override void visitJoinClause(JoinClause e, void arg) { visit(e.primary, arg); visitList(e.joins, arg); } @override void visitLimit(Limit e, void arg) { keyword(TokenType.limit); visit(e.count, arg); if (e.offset != null) { keyword(TokenType.offset); visit(e.offset!, arg); } } @override void visitNamedVariable(ColonNamedVariable e, void arg) { // Note: The name already starts with the colon symbol(e.name, spaceBefore: true, spaceAfter: true); } @override void visitNullLiteral(NullLiteral e, void arg) { keyword(TokenType.$null); } @override void visitNumberedVariable(NumberedVariable e, void arg) { symbol('?', spaceBefore: true, spaceAfter: e.explicitIndex == null); if (e.explicitIndex != null) { symbol(e.explicitIndex.toString(), spaceAfter: true); } } @override void visitNumericLiteral(NumericLiteral e, void arg) { symbol(e.value.toString(), spaceBefore: true, spaceAfter: true); } @override void visitOrderBy(OrderBy e, void arg) { keyword(TokenType.order); keyword(TokenType.by); _join(e.terms, ','); } @override void visitOrderingTerm(OrderingTerm e, void arg) { visit(e.expression, arg); _orderingMode(e.orderingMode); if (e.nulls != null) { keyword(TokenType.nulls); keyword(const { OrderingBehaviorForNulls.first: TokenType.first, OrderingBehaviorForNulls.last: TokenType.last, }[e.nulls!]!); } } @override void visitParentheses(Parentheses e, void arg) { symbol('('); visit(e.expression, arg); symbol(')'); } @override void visitRaiseExpression(RaiseExpression e, void arg) { keyword(TokenType.raise); symbol('(', spaceBefore: true); keyword(const { RaiseKind.ignore: TokenType.ignore, RaiseKind.rollback: TokenType.rollback, RaiseKind.abort: TokenType.abort, RaiseKind.fail: TokenType.fail, }[e.raiseKind]!); if (e.errorMessage != null) { symbol(',', spaceAfter: true); _stringLiteral(e.errorMessage!); } symbol(')', spaceAfter: true); } @override void visitReference(Reference e, void arg) { var didWriteSpaceBefore = false; if (e.schemaName != null) { identifier(e.schemaName!, spaceAfter: false); symbol('.'); didWriteSpaceBefore = true; } if (e.entityName != null) { identifier(e.entityName!, spaceAfter: false, spaceBefore: !didWriteSpaceBefore); symbol('.'); didWriteSpaceBefore = true; } identifier(e.columnName, spaceAfter: true, spaceBefore: !didWriteSpaceBefore); } @override void visitReturning(Returning e, void arg) { keyword(TokenType.returning); _join(e.columns, ','); } @override void visitSelectInsertSource(SelectInsertSource e, void arg) { visit(e.stmt, arg); } @override void visitSelectStatement(SelectStatement e, void arg) { visitNullable(e.withClause, arg); keyword(TokenType.select); if (e.distinct) { keyword(TokenType.distinct); } _join(e.columns, ','); _from(e.from); _where(e.where); visitNullable(e.groupBy, arg); if (e.windowDeclarations.isNotEmpty) { keyword(TokenType.window); var isFirst = true; for (final declaration in e.windowDeclarations) { if (!isFirst) { symbol(',', spaceAfter: true); } identifier(declaration.name); keyword(TokenType.as); visit(declaration.definition, arg); isFirst = false; } } visitNullable(e.orderBy, arg); visitNullable(e.limit, arg); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, void arg) { symbol('(', spaceBefore: true); visit(e.statement, arg); symbol(')', spaceAfter: true); if (e.as != null) { keyword(TokenType.as); identifier(e.as!); } } @override void visitSemicolonSeparatedStatements( SemicolonSeparatedStatements e, void arg) { for (final stmt in e.statements) { visit(stmt, arg); buffer.writeln(';'); needsSpace = false; } } @override void visitSingleColumnSetComponent(SingleColumnSetComponent e, void arg) { visit(e.column, arg); symbol('=', spaceBefore: true, spaceAfter: true); visit(e.expression, arg); } @override void visitMultiColumnSetComponent(MultiColumnSetComponent e, void arg) { symbol('(', spaceBefore: true); _join(e.columns, ','); symbol(')'); symbol('=', spaceBefore: true, spaceAfter: true); visit(e.rowValue, arg); } @override void visitStarFunctionParameter(StarFunctionParameter e, void arg) { symbol('*', spaceAfter: true); } @override void visitStarResultColumn(StarResultColumn e, void arg) { if (e.tableName != null) { identifier(e.tableName!); symbol('.'); } symbol('*', spaceAfter: true, spaceBefore: e.tableName == null); } @override void visitStringComparison(StringComparisonExpression e, void arg) { visit(e.left, arg); if (e.not) { keyword(TokenType.not); } keyword(e.operator.type); visit(e.right, arg); if (e.escape != null) { keyword(TokenType.escape); visit(e.escape!, arg); } } @override void visitStringLiteral(StringLiteral e, void arg) { if (e.isBinary) { symbol('X', spaceBefore: true); } _stringLiteral(e.value); } @override void visitSubQuery(SubQuery e, void arg) { symbol('(', spaceBefore: true); visit(e.select, arg); symbol(')', spaceAfter: true); } @override void visitTableConstraint(TableConstraint e, void arg) { if (e.name != null) { keyword(TokenType.constraint); identifier(e.name!); } if (e is KeyClause) { if (e.isPrimaryKey) { keyword(TokenType.primary); keyword(TokenType.key); } else { keyword(TokenType.unique); } symbol('('); _join(e.columns, ','); symbol(')'); _conflictClause(e.onConflict); } else if (e is CheckTable) { keyword(TokenType.check); symbol('('); visit(e.expression, arg); symbol(')'); } else if (e is ForeignKeyTableConstraint) { keyword(TokenType.foreign); keyword(TokenType.key); symbol('('); _join(e.columns, ','); symbol(')'); visit(e.clause, arg); } } @override void visitTableReference(TableReference e, void arg) { if (e.schemaName != null) { identifier(e.schemaName!, spaceAfter: false); symbol('.'); } identifier(e.tableName, spaceBefore: e.schemaName == null); if (e.as != null) { keyword(TokenType.as); identifier(e.as!); } } @override void visitTableValuedFunction(TableValuedFunction e, void arg) { identifier(e.name); symbol('('); visit(e.parameters, arg); symbol(')'); if (e.as != null) { keyword(TokenType.as); identifier(e.as!); } } @override void visitTimeConstantLiteral(TimeConstantLiteral e, void arg) { switch (e.kind) { case TimeConstantKind.currentTime: keyword(TokenType.currentTime); break; case TimeConstantKind.currentDate: keyword(TokenType.currentDate); break; case TimeConstantKind.currentTimestamp: keyword(TokenType.currentTimestamp); break; } } @override void visitTuple(Tuple e, void arg) { symbol('(', spaceBefore: true); _join(e.expressions, ','); symbol(')', spaceAfter: true); } @override void visitUnaryExpression(UnaryExpression e, void arg) { switch (e.operator.type) { case TokenType.minus: symbol('-', spaceBefore: true); break; case TokenType.plus: symbol('+', spaceBefore: true); break; case TokenType.tilde: symbol('~', spaceBefore: true); break; case TokenType.not: keyword(TokenType.not); break; default: throw AssertionError('Unknown unary operator: ${e.operator}'); } visit(e.inner, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { visitNullable(e.withClause, arg); keyword(TokenType.update); if (e.or != null) { keyword(TokenType.or); keyword(const { FailureMode.rollback: TokenType.rollback, FailureMode.abort: TokenType.abort, FailureMode.replace: TokenType.replace, FailureMode.fail: TokenType.fail, FailureMode.ignore: TokenType.ignore, }[e.or!]!); } visit(e.table, arg); keyword(TokenType.set); _join(e.set, ','); _from(e.from); _where(e.where); visitNullable(e.returning, arg); } @override void visitUpdateTriggerTarget(UpdateTarget e, void arg) { keyword(TokenType.update); if (e.columnNames.isNotEmpty) { keyword(TokenType.of); _join(e.columnNames, ','); } } @override void visitUpsertClause(UpsertClause e, void arg) { _join(e.entries, ''); } @override void visitUpsertClauseEntry(UpsertClauseEntry e, void arg) { keyword(TokenType.on); keyword(TokenType.conflict); if (e.onColumns != null) { symbol('(', spaceBefore: true); _join(e.onColumns!, ','); symbol(')', spaceAfter: true); _where(e.where); } keyword(TokenType.$do); visit(e.action, arg); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { keyword(TokenType.$values); _join(e.values, ','); } @override void visitValuesSource(ValuesSource e, void arg) { keyword(TokenType.$values); _join(e.values, ','); } @override void visitWhen(WhenComponent e, void arg) { keyword(TokenType.when); visit(e.when, arg); keyword(TokenType.then); visit(e.then, arg); } @override void visitWindowDefinition(WindowDefinition e, void arg) { symbol('(', spaceBefore: true); if (e.baseWindowName != null) { identifier(e.baseWindowName!); } if (e.partitionBy.isNotEmpty) { keyword(TokenType.partition); keyword(TokenType.by); _join(e.partitionBy, ','); } visitNullable(e.orderBy, arg); visitNullable(e.frameSpec, arg); symbol(')', spaceAfter: true); } @override void visitWithClause(WithClause e, void arg) { keyword(TokenType.$with); if (e.recursive) { keyword(TokenType.recursive); } _join(e.ctes, ','); } void _conflictClause(ConflictClause? clause) { if (clause != null) { keyword(TokenType.on); keyword(TokenType.conflict); keyword(const { ConflictClause.rollback: TokenType.rollback, ConflictClause.abort: TokenType.abort, ConflictClause.fail: TokenType.fail, ConflictClause.ignore: TokenType.ignore, ConflictClause.replace: TokenType.replace, }[clause]!); } } void _from(Queryable? from) { if (from != null) { keyword(TokenType.from); visit(from, null); } } /// Writes an identifier, escaping it if necessary. void identifier(String identifier, {bool spaceBefore = true, bool spaceAfter = true}) { if (isKeyword(identifier) || _notAKeywordRegex.hasMatch(identifier)) { identifier = escapeIdentifier(identifier); } symbol(identifier, spaceBefore: spaceBefore, spaceAfter: spaceAfter); } void dartCode(String code, {bool spaceBefore = true, bool spaceAfter = true}) { symbol('`$code`', spaceBefore: spaceBefore, spaceAfter: spaceAfter); } void _ifNotExists(bool ifNotExists) { if (ifNotExists) { keyword(TokenType.$if); keyword(TokenType.not); keyword(TokenType.exists); } } void _join(Iterable nodes, String separatingSymbol) { var isFirst = true; for (final node in nodes) { if (!isFirst) { symbol(separatingSymbol, spaceAfter: true); } visit(node, null); isFirst = false; } } void keyword(TokenType type) { symbol(reverseKeywords[type]!, spaceAfter: true, spaceBefore: true); } void _orderingMode(OrderingMode? mode) { if (mode != null) { keyword(const { OrderingMode.ascending: TokenType.asc, OrderingMode.descending: TokenType.desc, }[mode]!); } } void _space() => buffer.writeCharCode($space); void _stringLiteral(String content) { final escapedChars = content.replaceAll("'", "''"); symbol("'$escapedChars'", spaceBefore: true, spaceAfter: true); } /// Writes the [lexeme], unchanged. void symbol(String lexeme, {bool spaceBefore = false, bool spaceAfter = false}) { if (needsSpace && spaceBefore) { _space(); } buffer.write(lexeme); needsSpace = spaceAfter; } void _where(Expression? where) { if (where != null) { keyword(TokenType.where); visit(where, null); } } } /// Defines the [toSql] extension method that turns ast nodes into a compatible /// textual representation. /// /// Parsing the output of [toSql] will result in an equal AST. extension NodeToText on AstNode { /// Obtains a textual representation for AST nodes. /// /// Parsing the output of [toSql] will result in an equal AST. Since only the /// AST is used, the output will not contain comments. It's possible for the /// output to have more than just whitespace changes if there are multiple /// ways to represent an equivalent node (e.g. the no-op `FOR EACH ROW` on /// triggers). String toSql() { final builder = NodeSqlBuilder(null); builder.visit(this, null); return builder.buffer.toString(); } } // Allow 0, 1, 2, 3 in https://github.com/sqlite/sqlite/blob/665b6b6b35f10a46bb72377ade7c2e5d8ea42cb3/src/tokenize.c#L62-L80 final _notAKeywordRegex = RegExp('[^A-Za-z_0-9]'); lib/utils/case_insensitive_map.dart 644 0 0 1665 14612235271 15647 0ustar0 pubpubimport 'dart:collection'; /// A map from strings to [T] where keys are compared without case sensitivity. class CaseInsensitiveMap extends MapBase { final Map _normalized = {}; CaseInsensitiveMap(); factory CaseInsensitiveMap.of(Map other) { final map = CaseInsensitiveMap(); other.forEach((key, value) { map[key] = value; }); return map; } @override T? operator [](Object? key) { if (key is String?) { return _normalized[key?.toLowerCase()]; } else { return null; } } @override void operator []=(K key, T value) { _normalized[key?.toLowerCase() as K] = value; } @override void clear() { _normalized.clear(); } @override Iterable get keys => _normalized.keys; @override T? remove(Object? key) { if (key is String?) { return _normalized.remove(key?.toLowerCase()); } return null; } } lib/utils/find_referenced_tables.dart 644 0 0 13776 14711507160 16140 0ustar0 pubpublibrary utils.find_referenced_tables; import 'package:sqlparser/sqlparser.dart'; import 'node_to_text.dart'; /// An AST-visitor that walks sql statements and finds all tables referenced in /// them. class ReferencedTablesVisitor extends RecursiveVisitor { /// All tables that have been referenced anywhere in this query. final Set foundTables = {}; final Set foundViews = {}; void _add(NamedResultSet? resultSet) { if (resultSet is Table) { foundTables.add(resultSet); } else if (resultSet is View) { foundViews.add(resultSet); } } @override void visitReference(Reference e, void arg) { var column = e.resolved; while (column is DelegatedColumn) { column = column.innerColumn; } if (column is TableColumn) { _add(column.table); } else if (column is ViewColumn) { _add(column.view); } visitChildren(e, arg); } NamedResultSet? _toResultSetOrNull(ResolvesToResultSet? resultSet) { final resolved = resultSet?.resultSet?.unalias(); return resolved is NamedResultSet ? resolved : null; } @override void visitTableReference(TableReference e, void arg) { final resolved = _toResultSetOrNull(e.resultSet); if (resolved != null) { _add(resolved); } visitChildren(e, arg); } } enum UpdateKind { insert, update, delete } /// A write to a table or view as found while analyzing a statement. /// /// While views normally can't be written to, sqlite3 supports `INSTEAD OF` /// triggers allowing other statements to be executed when running writes on /// views. class TableWrite { /// The table that a statement might write to when run. final NamedResultSet table; /// What kind of update was found (e.g. insert, update or delete). final UpdateKind kind; TableWrite(this.table, this.kind); @override int get hashCode => 37 * table.hashCode + kind.hashCode; @override bool operator ==(Object other) { return other is TableWrite && other.table == table && other.kind == kind; } } /// Finds all tables that could be affected when executing a query. In /// contrast to [ReferencedTablesVisitor], which finds all references, this /// visitor only collects tables a query writes to. class UpdatedTablesVisitor extends ReferencedTablesVisitor { /// All tables that can potentially be updated by this query. /// /// Note that this is a subset of [foundTables], since an updating tables /// could reference tables it's not updating (e.g. with `INSERT INTO foo /// SELECT * FROM bar`). final Set writtenTables = {}; void _addIfResolved(ResolvesToResultSet? r, UpdateKind kind) { final resolved = _toResultSetOrNull(r); if (resolved != null && (resolved is Table || resolved is View)) { writtenTables.add(TableWrite(resolved, kind)); } } @override void visitDeleteStatement(DeleteStatement e, void arg) { _addIfResolved(e.from, UpdateKind.delete); visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { _addIfResolved(e.table, UpdateKind.update); visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { _addIfResolved(e.table, UpdateKind.insert); visitChildren(e, arg); } } /// Finds all writes to a table that occur anywhere inside the [root] node or a /// descendant. /// /// The [root] node must have all its references resolved. This means that using /// a node obtained via [SqlEngine.parse] directly won't report meaningful /// results. Instead, use [SqlEngine.analyze] or [SqlEngine.analyzeParsed]. /// /// If you want to find all referenced tables, use [findReferencedTables]. If /// you want to find writes (including their [UpdateKind]) and referenced /// tables, constrct a [UpdatedTablesVisitor] manually. /// Then, let it visit the [root] node. You can now use /// [UpdatedTablesVisitor.writtenTables] and /// [ReferencedTablesVisitor.foundTables]. This will only walk the ast once, /// whereas calling this and [findReferencedTables] will require two walks. /// Set findWrittenTables(AstNode root) { return (UpdatedTablesVisitor()..visit(root, null)).writtenTables; } /// Finds all tables referenced in [root] or a descendant. /// /// The [root] node must have all its references resolved. This means that using /// a node obtained via [SqlEngine.parse] directly won't report meaningful /// results. Instead, use [SqlEngine.analyze] or [SqlEngine.analyzeParsed]. /// /// If you want to use both [findWrittenTables] and this on the same ast node, /// follow the advice on [findWrittenTables] to only walk the ast once. Set
findReferencedTables(AstNode root) { return (ReferencedTablesVisitor()..visit(root, null)).foundTables; } /// Extension to find referenced tables prior to any analysis runs. extension FindReferenceAnalysis on SqlEngine { /// Finds tables references from the global schema before any analyis steps /// ran. /// /// This includes tables added in `FROM` if those tables haven't been added /// syntactically, for instance through a `WITH` clause. /// /// In a sense, this is comparable to finding "free variables" in a syntactic /// construct for other languages. Set findReferencedSchemaTables(AstNode root) { // Poorly clone the AST so that the analysis doesn't bring the original one // into a weird state. final sql = root.toSql(); final clone = parse(sql).rootNode; final scope = _FakeRootScope(); final context = AnalysisContext(clone, sql, scope, EngineOptions(), schemaSupport: schemaReader); AstPreparingVisitor(context: context).start(clone); clone.accept(ColumnResolver(context), const ColumnResolverContext()); return scope.addedTables; } } class _FakeRootScope extends RootScope { final Set addedTables = {}; @override ResultSet? resolveResultSetToAdd(String name) { addedTables.add(name.toLowerCase()); return _FakeResultSet(); } } class _FakeResultSet extends ResultSet { @override List? get resolvedColumns => const []; } mono_pkg.yaml 644 0 0 223 14345646642 11352 0ustar0 pubpubdart: - stable stages: - analyze: - dartanalyzer: --fatal-infos --fatal-warnings lib/ test/ - dartfmt - unit_test: - test test 755 0 0 0 0 7203 5ustar0 pubpubtest/common_data.dart 644 0 0 1131 14345646642 13010 0ustar0 pubpubconst createTableStmt = ''' CREATE TABLE IF NOT EXISTS users ( id INT NOT NULL PRIMARY KEY DESC ON CONFLICT ROLLBACK AUTOINCREMENT, email VARCHAR NOT NULL UNIQUE ON CONFLICT ABORT, score INT CONSTRAINT "score set" NOT NULL DEFAULT 420 CHECK (score > 0), display_name VARCHAR NULL COLLATE BINARY REFERENCES some(thing) ON UPDATE CASCADE ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED, UNIQUE (score, display_name) ON CONFLICT ABORT, FOREIGN KEY (id, email) REFERENCES another (a, b) ON DELETE NO ACTION ON UPDATE RESTRICT NOT DEFERRABLE INITIALLY IMMEDIATE ) '''; test/scanner 755 0 0 0 0 10634 5ustar0 pubpubtest/scanner/recognizes_all_tokens_test.dart 644 0 0 3324 14711507160 17574 0ustar0 pubpub@TestOn('vm') library; import 'dart:convert'; import 'dart:ffi'; import 'package:ffi/ffi.dart'; import 'package:sqlite3/open.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; typedef SqliteKeywordCountNative = Int32 Function(); typedef SqliteKeywordCount = int Function(); typedef SqliteKeywordNameNative = Int32 Function( Int32, Pointer>, Pointer); typedef SqliteKeywordName = int Function( int, Pointer>, Pointer); void main() { String? skip; late DynamicLibrary library; try { library = open.openSqlite(); // Some platforms have sqlite3, but no sqlite3_keyword_count library.lookup('sqlite3_keyword_count'); } on Object { skip = 'sqlite3 is not available in test environment'; } test( 'recognizes all sqlite keywords', () { final keywordCount = library.lookupFunction( 'sqlite3_keyword_count')(); final nameFunction = library.lookupFunction( 'sqlite3_keyword_name'); final charOut = malloc>(); final lengthOut = malloc(); final missingNames = []; for (var i = 0; i < keywordCount; i++) { nameFunction(i, charOut, lengthOut); final bytes = charOut.value.asTypedList(lengthOut.value); final name = utf8.decode(bytes); if (!keywords.containsKey(name)) { missingNames.add(name); } } missingNames.sort(); malloc.free(charOut); malloc.free(lengthOut); expect(missingNames, isEmpty); }, skip: skip, ); } test/scanner/drift_tokens_test.dart 644 0 0 1472 14345646642 15722 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; void main() { test('parses drift specific tokens', () { const part = 'c INTEGER MAPPED BY `const Mapper()` NOT NULL **'; final scanner = Scanner(part, scanDriftTokens: true); final tokens = scanner.scanTokens(); expect(scanner.errors, isEmpty); expect(tokens.map((t) => t.type), [ TokenType.identifier, // c TokenType.identifier, // INTEGER TokenType.mapped, TokenType.by, TokenType.inlineDart, // `const Mapper()` TokenType.not, TokenType.$null, TokenType.doubleStar, TokenType.eof, ]); expect( tokens.whereType().single.dartCode, 'const Mapper()'); }); } test/scanner/single_token_test.dart 644 0 0 12431 14711507160 15711 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; void expectFullToken(String token, TokenType type) { final scanner = Scanner(token); List tokens; try { tokens = scanner.scanTokens(); } catch (e, s) { print(e); print(s); fail('Parsing error while parsing $token'); } if (tokens.length != 2 || tokens.last.type != TokenType.eof) { fail('Expected exactly one token when parsing $token, ' 'got ${tokens.length - 1}'); } expect(tokens.first.type, type, reason: '$token is a $type'); expect(tokens.first.span.text, token); } Map testCases = { '(': TokenType.leftParen, ')': TokenType.rightParen, ',': TokenType.comma, '.': TokenType.dot, '+': TokenType.plus, '-': TokenType.minus, '*': TokenType.star, '/': TokenType.slash, '<=': TokenType.lessEqual, '<': TokenType.less, '>=': TokenType.moreEqual, '>': TokenType.more, '!=': TokenType.exclamationEqual, "'hello there'": TokenType.stringLiteral, "''": TokenType.stringLiteral, '1.123': TokenType.numberLiteral, '1.32e5': TokenType.numberLiteral, '.123e-3': TokenType.numberLiteral, '0xFF13': TokenType.numberLiteral, '0Xf13A': TokenType.numberLiteral, 'SELECT': TokenType.select, '"UPDATE"': TokenType.identifier, '@foo': TokenType.atSignVariable, ':named': TokenType.colonVariable, '"spo\uD83C\uDF83ky"': TokenType.identifier, '[account name]': TokenType.identifier, }; void main() { group('single token:', () { for (final entry in testCases.entries) { test('parses ${entry.key}', () { expectFullToken(entry.key, entry.value); }); } }); test('can escape strings', () { final scanner = Scanner("'what''s up'"); scanner.scanTokens(); expect(scanner.tokens, hasLength(2)); // eof token at the end expect( scanner.tokens.first, const TypeMatcher() .having((token) => token.value, 'value', "what's up"), ); expect(scanner.tokens[1].type, TokenType.eof); }); test('issues error for unterminated string literals', () { final scanner = Scanner("'unterminated")..scanTokens(); expect( scanner.errors, contains(const TypeMatcher() .having((e) => e.message, 'message', 'Unterminated string')), ); }); test('binary string literal', () { final scanner = Scanner("X'1234' x'5678'"); scanner.scanTokens(); expect(scanner.tokens, hasLength(3)); expect( scanner.tokens[0], const TypeMatcher() .having((token) => token.binary, 'binary', isTrue) .having((token) => token.value, 'value', '1234'), ); expect( scanner.tokens[1], const TypeMatcher() .having((token) => token.binary, 'binary', isTrue) .having((token) => token.value, 'value', '5678'), ); expect(scanner.tokens[2].type, TokenType.eof); }); group('parses numeric literals', () { void checkLiteral(String lexeme, NumericToken other, num value) { final scanner = Scanner(lexeme)..scanTokens(); final token = scanner.tokens.first as NumericToken; expect(token.hasSameStructureAs(other), isTrue, reason: '$token should have the same structure as $other'); expect(token.parsedNumber, equals(value)); } test('hexadecimal', () { checkLiteral('0x123', NumericToken(defaultSpan, hexDigits: '123'), 0x123); checkLiteral( '0x12_34', NumericToken(defaultSpan, hexDigits: '1234'), 0x1234); }); test('integer without exponent', () { checkLiteral( '42', NumericToken(defaultSpan, digitsBeforeDecimal: '42'), 42); checkLiteral( '4_2', NumericToken(defaultSpan, digitsBeforeDecimal: '42'), 42); }); test('integer, positive exponent', () { checkLiteral( '42E1', NumericToken(defaultSpan, digitsBeforeDecimal: '42', exponent: 1), 420); }); test('integer, negative exponent', () { checkLiteral( '42E-1', NumericToken(defaultSpan, digitsBeforeDecimal: '42', exponent: -1), 4.2); checkLiteral( '42E-1_0', NumericToken(defaultSpan, digitsBeforeDecimal: '42', exponent: -10), 4.2e-9); }); test('decimal', () { checkLiteral( '4.2', NumericToken( defaultSpan, digitsBeforeDecimal: '4', digitsAfterDecimal: '2', hasDecimalPoint: true, ), 4.2, ); checkLiteral( '4_3.2_1', NumericToken( defaultSpan, digitsBeforeDecimal: '43', digitsAfterDecimal: '21', hasDecimalPoint: true, ), 43.21, ); }); test('decimal, nothing after decimal dot', () { checkLiteral( '4.e2', NumericToken( defaultSpan, digitsBeforeDecimal: '4', exponent: 2, hasDecimalPoint: true, ), 400.0, ); }); test('decimal, nothing before decimal dot', () { checkLiteral( '.2', NumericToken( defaultSpan, digitsAfterDecimal: '2', hasDecimalPoint: true, ), .2, ); }); }); } test/scanner/scanner_test.dart 644 0 0 6032 14720702252 14640 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; void main() { test('parses ** as two tokens when not using drift mode', () { final tokens = Scanner('**').scanTokens(); expect(tokens.map((e) => e.type), containsAllInOrder([TokenType.star, TokenType.star])); }); test('throws when seeing an invalid token', () { expect( () => SqlEngine().tokenize('!'), throwsA(isA()), ); }); test('scans identifiers with backticks', () { expect( Scanner('`SELECT`').scanTokens(), contains(isA() .having((e) => e.identifier, 'identifier', 'SELECT')), ); }); test('scans identifiers with double quotes', () { expect( Scanner('"SELECT"').scanTokens(), contains(isA() .having((e) => e.identifier, 'identifier', 'SELECT')), ); }); test('scans new tokens for JSON extraction', () { expect(Scanner('- -> ->>').scanTokens(), [ isA().having((e) => e.type, 'tokenType', TokenType.minus), isA().having((e) => e.type, 'tokenType', TokenType.dashRangle), isA() .having((e) => e.type, 'tokenType', TokenType.dashRangleRangle), isA().having((e) => e.type, 'tokenType', TokenType.eof), ]); }); group('reports error message', () { test(r'for missing identifier after `$`', () { expect( () => SqlEngine().tokenize(r'$ order'), throwsA( isA().having( (e) => e.errors, 'errors', contains( isA() .having((e) => e.message, 'message', r'Expected identifier after `$`') .having((e) => e.location.offset, 'location.offset', 1), ), ), ), ); }); test('for missing identifier after `@`', () { expect( () => SqlEngine().tokenize('@ order'), throwsA( isA().having( (e) => e.errors, 'errors', contains( isA() .having((e) => e.message, 'message', r'Expected identifier after `@`') .having((e) => e.location.offset, 'location.offset', 1), ), ), ), ); }); }); test('does not crash on non-SQL input', () async { // Regression test for https://github.com/simolus3/drift/issues/3273#issuecomment-2468988502 const badInput = ''' class Screen extends ConsumerStatefulWidget { const Screen({super.key}); @override ConsumerState createState() => _ScreenState(); } '''; expect(() => SqlEngine().tokenize(badInput), throwsA(isA())); final parsed = SqlEngine().parse(badInput); expect(parsed.errors, isNotEmpty); expect(parsed.rootNode, isA()); }); } test/scanner/utils_test.dart 644 0 0 3032 14345646642 14361 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/utils.dart'; import 'package:test/test.dart'; void main() { test('isDigit', () { expect(isDigit('0'.codeUnitAt(0)), isTrue); expect(isDigit('3'.codeUnitAt(0)), isTrue); expect(isDigit('9'.codeUnitAt(0)), isTrue); expect(isDigit('a'.codeUnitAt(0)), isFalse); expect(isDigit('x'.codeUnitAt(0)), isFalse); }); test('isHexDigit', () { expect(isHexDigit('0'.codeUnitAt(0)), isTrue); expect(isHexDigit('3'.codeUnitAt(0)), isTrue); expect(isHexDigit('9'.codeUnitAt(0)), isTrue); expect(isHexDigit('a'.codeUnitAt(0)), isTrue); expect(isHexDigit('C'.codeUnitAt(0)), isTrue); expect(isHexDigit('F'.codeUnitAt(0)), isTrue); expect(isDigit('x'.codeUnitAt(0)), isFalse); expect(isDigit('G'.codeUnitAt(0)), isFalse); }); test('canStartIdentifier', () { expect(canStartIdentifier('_'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('a'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('C'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('Z'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('['.codeUnitAt(0)), isFalse); expect(canStartIdentifier('0'.codeUnitAt(0)), isFalse); }); test('continuesIdentifier', () { expect(continuesIdentifier('_'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('a'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('Z'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('0'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('['.codeUnitAt(0)), isFalse); }); } test/scanner/comments_test.dart 644 0 0 1765 14345646642 15061 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; void main() { test('scanns comments', () { const sql = r''' --line -- line /*c*/ /*multi line */ /* not terminated'''; // using whereType instead of cast because of the invisible eof token final tokens = Scanner(sql).scanTokens().whereType(); expect(tokens.map((t) => t.mode), [ CommentMode.line, CommentMode.line, CommentMode.cStyle, CommentMode.cStyle, CommentMode.cStyle, ]); expect(tokens.map((t) => t.content), [ 'line', ' line', 'c', 'multi\n line ', ' not terminated', ]); }); test('supports -- comments on last line', () { const sql = '-- not much to see'; final tokens = Scanner(sql).scanTokens(); expect(tokens, hasLength(2)); expect((tokens[0] as CommentToken).content, ' not much to see'); expect(tokens[1].type, TokenType.eof); }); } test/parser 755 0 0 0 0 10477 5ustar0 pubpubtest/parser/delete_test.dart 644 0 0 1310 14354621567 14322 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses delete statements', () { testStatement( 'DELETE FROM tbl WHERE id = 5', DeleteStatement( from: TableReference('tbl'), where: BinaryExpression( Reference(columnName: 'id'), token(TokenType.equal), NumericLiteral( 5, ), ), ), ); }); test('parses delete statements with RETURNING', () { testStatement( 'DELETE FROM tbl RETURNING *;', DeleteStatement( from: TableReference('tbl'), returning: Returning([StarResultColumn()]), ), ); }); } test/parser/partition_test.dart 644 0 0 5626 14612235271 15075 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map _testCases = { 'row_number() OVER (ORDER BY y)': WindowFunctionInvocation( function: identifier('row_number'), parameters: ExprFunctionParameters(), windowDefinition: WindowDefinition( frameSpec: FrameSpec(), orderBy: OrderBy(terms: [ OrderingTerm(expression: Reference(columnName: 'y')), ]), ), ), 'row_number(*) FILTER (WHERE 1) OVER ' '(base_name PARTITION BY a, b ' 'GROUPS BETWEEN UNBOUNDED PRECEDING AND 3 FOLLOWING EXCLUDE TIES)': WindowFunctionInvocation( function: identifier('row_number'), parameters: StarFunctionParameter(), filter: NumericLiteral(1), windowDefinition: WindowDefinition( baseWindowName: 'base_name', partitionBy: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], frameSpec: FrameSpec( type: FrameType.groups, start: FrameBoundary.unboundedPreceding(), end: FrameBoundary.following( NumericLiteral(3), ), excludeMode: ExcludeMode.ties, ), ), ), 'row_number() OVER (RANGE CURRENT ROW EXCLUDE NO OTHERS)': WindowFunctionInvocation( function: identifier('row_number'), parameters: ExprFunctionParameters(), windowDefinition: WindowDefinition( frameSpec: FrameSpec( type: FrameType.range, start: FrameBoundary.currentRow(), end: FrameBoundary.currentRow(), excludeMode: ExcludeMode.noOthers, ), ), ), 'COUNT(is_skipped) FILTER (WHERE is_skipped = true)': AggregateFunctionInvocation( function: identifier('COUNT'), parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'is_skipped')], ), filter: BinaryExpression( Reference(columnName: 'is_skipped'), token(TokenType.equal), BooleanLiteral(true), ), ), "string_agg(foo, ', ' ORDER BY foo DESC)": AggregateFunctionInvocation( function: identifier('string_agg'), parameters: ExprFunctionParameters(parameters: [ Reference(columnName: 'foo'), StringLiteral(', '), ]), orderBy: OrderBy(terms: [ OrderingTerm( expression: Reference(columnName: 'foo'), orderingMode: OrderingMode.descending, ), ]), ), }; void main() { group('partition parses', () { _testCases.forEach((sql, expected) { test(sql, () { final scanner = Scanner(sql); final tokens = scanner.scanTokens(); final parser = Parser(tokens); final expression = parser.expression(); enforceHasSpan(expression); enforceEqual(expression, expected); }); }); }); } test/parser/errors_test.dart 644 0 0 3175 14612235271 14375 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('WITH without following statement', () { expectError('WITH foo AS (SELECT * FROM bar)', [isParsingError(message: contains('to follow this WITH clause'))]); }); test('CREATE without following statement', () { expectError('CREATE', [ isParsingError(message: contains('after the CREATE keyword')), ]); expectError('create from table_name', [ isParsingError(message: contains('after the CREATE keyword')), ]); }); group('when using keywords', () { test('for function calls', () { expectError('SELECT replace(a, b, c);', [ isParsingError( message: contains('Did you mean to call a function?'), span: 'replace', ), ]); }); test('as identifiers', () { expectError('SELECT group FROM foo;', [ isParsingError( message: contains('Did you mean to use it as a column?'), span: 'group', ), ]); expectError('CREATE TABLE x (table TEXT NOT NULL, foo INTEGER);', [ isParsingError( message: 'Expected a column name (got keyword TABLE)', span: 'table', ), ]); }); test('recovers from invalid comma after table reference', () { expectError('SELECT * FROM table_name,', [ isParsingError( message: 'Expected a table name or a nested select statement', ), ]); }); }); } void expectError(String sql, errorsMatcher) { final parsed = SqlEngine().parse(sql); expect(parsed.errors, errorsMatcher); } test/parser/regression_909_test.dart 644 0 0 4270 14345646642 15652 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; // ignore_for_file: lines_longer_than_80_chars void main() { const stmts = [ 'CREATE TABLE plots (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, name VARCHAR NOT NULL, crop VARCHAR NOT NULL, crop_variety VARCHAR NOT NULL, planting_date INTEGER NOT NULL, is_outdoor_trial INTEGER NOT NULL CHECK (is_outdoor_trial in (0, 1)), uses_crop_blanket INTEGER NOT NULL CHECK (uses_crop_blanket in (0, 1)), is_raised_bed INTEGER NOT NULL CHECK (is_raised_bed in (0, 1)), plant_spacing REAL NOT NULL, row_spacing REAL NOT NULL, irrigation_type VARCHAR NOT NULL, rows_per_bed REAL NULL, bed_spacing REAL NULL, coordinates VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE lab_reports (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, sample_date INTEGER NOT NULL, source VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE dissipated_active_ingredients (id VARCHAR NOT NULL, lab_report_id VARCHAR NOT NULL, active_ingredient_id VARCHAR NULL, name VARCHAR NULL, residue REAL NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE sprays (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, create_date INTEGER NOT NULL, application_method VARCHAR NOT NULL, growth_stage VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE products (id VARCHAR NOT NULL, trade_name VARCHAR NOT NULL, type VARCHAR NOT NULL, owner_id VARCHAR NULL, PRIMARY KEY (id))', 'CREATE TABLE markets (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, name VARCHAR NOT NULL, mrl REAL NOT NULL, arfd REAL NOT NULL, adi REAL NOT NULL, total_active_ingredients INTEGER NOT NULL, PRIMARY KEY (id))', ]; test('parses statements', () { final engine = SqlEngine(); for (final stmt in stmts) { final result = engine.parse(stmt); expect(result.errors, isEmpty); expect(result.rootNode, isA()); } }); } test/parser/utils.dart 644 0 0 4670 14612235271 13163 0ustar0 pubpubimport 'package:collection/collection.dart' show IterableExtension; import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; export 'package:sqlparser/src/reader/tokenizer/token.dart'; final defaultSpan = fakeSpan('fake'); Token token(TokenType type) { return Token(type, defaultSpan); } StringLiteralToken stringLiteral(String value) { return StringLiteralToken(value, defaultSpan); } InlineDartToken inlineDart(String dartCode) { return InlineDartToken(fakeSpan('`$dartCode`')); } IdentifierToken identifier(String content) { return IdentifierToken(false, fakeSpan(content)); } DriftFile parseDrift(String content) { return SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parseDriftFile(content) .rootNode as DriftFile; } void testDriftFile(String driftFile, DriftFile expected) { final parsed = parseDrift(driftFile); enforceHasSpan(parsed); enforceEqual(parsed, expected); } void testStatement(String sql, AstNode expected, {bool driftMode = false}) { final result = SqlEngine(EngineOptions( driftOptions: driftMode ? const DriftSqlOptions() : null)) .parse(sql); expect(result.errors, isEmpty); final parsed = result.rootNode; enforceHasSpan(parsed); enforceEqual(parsed, expected); } void expectParseError( String sql, { dynamic message = anything, dynamic span = anything, }) { final result = SqlEngine().parse(sql); expect(result.errors, [isParsingError(message: message, span: span)]); } TypeMatcher isParsingError({ dynamic message = anything, dynamic span = anything, }) { return isA() .having((e) => e.message, 'message', wrapMatcher(message)) .having((e) => e.token.span.text, 'span', wrapMatcher(span)); } FileSpan fakeSpan(String content) { return SourceFile.fromString(content).span(0); } void testAll(Map testCases) { testCases.forEach((sql, expected) { test('with $sql', () { testStatement(sql, expected); }); }); } /// The parser should make sure [AstNode.hasSpan] is true on relevant nodes. void enforceHasSpan(AstNode node) { final problematic = [node] .followedBy(node.allDescendants) .firstWhereOrNull((node) => !node.hasSpan && !node.synthetic); if (problematic != null) { throw ArgumentError('Node $problematic did not have a span'); } } test/parser/recovery_test.dart 644 0 0 10461 14711507160 14732 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses create table statements with a previous malformed inport', () { final file = parseDrift(''' import ; CREATE TABLE foo (name TEXT); '''); expect( file.childNodes, contains(const TypeMatcher())); }); test('recovers from parsing errors in column definition', () { final file = parseDrift(''' CREATE TABLE foo ( id INTEGER PRIMARY, name TEXT NOT NULL ); '''); final stmt = file.childNodes.single as CreateTableStatement; enforceEqual( stmt, CreateTableStatement( tableName: 'foo', columns: [ // id column can't be parsed because of the missing KEY ColumnDefinition( columnName: 'name', typeName: 'TEXT', constraints: [NotNull(null)], ), ], ), ); }); test('parses trailing comma with error', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())); final result = engine.parseDriftFile(''' CREATE TABLE foo ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, ); '''); expect(result.errors, hasLength(1)); enforceEqual( result.rootNode.childNodes.single, CreateTableStatement( tableName: 'foo', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [PrimaryKeyColumn(null)], ), ColumnDefinition( columnName: 'name', typeName: 'TEXT', constraints: [NotNull(null)], ), ], ), ); }); test('recovers from multiple syntax errors in table definitions', () { // Regression test for https://github.com/simolus3/drift/issues/3273 final engine = SqlEngine(); final result = engine.parseMultiple(''' CREATE TABLE IF NOT EXISTS "employees" ( "employee_id" INTEGER, "department_id" INTEGER NOT NULL, "employee_name" TEXT(100) NOT NULL, PRIMARY KEY("employee_id" AUTOINCREMENT) -- invalid table constraint ); CREATE TABLE IF NOT EXISTS "projects" ( "project_id" BIGINT AUTO_INCREMENT, -- invalid column constraint "employee_id" INT NOT NULL, "project_title" CHAR(255) NOT NULL, PRIMARY KEY("project_id", "employee_id") ); '''); expect(result.errors, [ isParsingError(span: 'AUTOINCREMENT'), isParsingError(span: 'AUTO_INCREMENT'), ]); enforceEqual( result.rootNode, SemicolonSeparatedStatements([ CreateTableStatement( tableName: 'employees', ifNotExists: true, columns: [ ColumnDefinition( columnName: 'employee_id', typeName: 'INTEGER', ), ColumnDefinition( columnName: 'department_id', typeName: 'INTEGER', constraints: [NotNull(null)], ), ColumnDefinition( columnName: 'employee_name', typeName: 'TEXT(100)', constraints: [NotNull(null)], ), ], tableConstraints: [ // The broken PRIMARY KEY is not included here, there's a syntax // error since we don't support AUTOINCREMENT here. ], ), CreateTableStatement( tableName: 'projects', ifNotExists: true, columns: [ ColumnDefinition( columnName: 'project_id', typeName: 'BIGINT', constraints: [ // The broken column constraint is not included ], ), ColumnDefinition( columnName: 'employee_id', typeName: 'INT', constraints: [NotNull(null)], ), ColumnDefinition( columnName: 'project_title', typeName: 'CHAR(255)', constraints: [NotNull(null)], ), ], tableConstraints: [ KeyClause(null, isPrimaryKey: true, columns: [ IndexedColumn(Reference(columnName: 'project_id')), IndexedColumn(Reference(columnName: 'employee_id')), ]) ], ), ]), ); }); } test/parser/create_trigger_test.dart 644 0 0 5350 14612235271 16044 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; final _block = Block([ UpdateStatement(table: TableReference('tbl'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'foo'), expression: Reference(columnName: 'bar'), ), ]), SelectStatement( columns: [StarResultColumn()], from: TableReference('tbl'), ), ]); void main() { test('parses create trigger statements', () { const sql = ''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER DELETE ON tbl FOR EACH ROW BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( ifNotExists: true, triggerName: 'my_trigger', mode: TriggerMode.after, target: DeleteTarget(), onTable: TableReference('tbl'), action: _block, ), ); }); test('with INSTEAD OF mode and UPDATE', () { const sql = ''' CREATE TRIGGER my_trigger INSTEAD OF UPDATE OF foo, bar ON tbl BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( triggerName: 'my_trigger', mode: TriggerMode.insteadOf, target: UpdateTarget([ Reference(columnName: 'foo'), Reference(columnName: 'bar'), ]), onTable: TableReference('tbl'), action: _block, ), ); }); test('with BEFORE, INSERT and WHEN clause', () { const sql = ''' CREATE TRIGGER my_trigger BEFORE INSERT ON tbl WHEN new.foo IS NULL BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( triggerName: 'my_trigger', mode: TriggerMode.before, target: InsertTarget(), onTable: TableReference('tbl'), when: IsExpression( false, Reference(entityName: 'new', columnName: 'foo'), NullLiteral(), ), action: _block, ), ); }); test('reports error for invalid statement in block', () { expectParseError( ''' CREATE TRIGGER "UserLogins_insert" AFTER INSERT ON "UserLogins" BEGIN INSERT INTO "SyncChanges"("table", "pk", "lastUpdateTime", "isDeleted") VALUES ('UserLogins', '{"userId": "' || new."userId" || '", "deviceId": "' || new."deviceId" || '"}', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), 0); ON CONFLICT("table", "pk") DO UPDATE SET "lastUpdateTime" = excluded."lastUpdateTime", "isDeleted" = excluded."isDeleted"; END; ''', message: contains('Invalid statement'), span: 'ON', ); }); } test/parser/drift_file_test.dart 644 0 0 16455 14612235271 15215 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; const content = r''' import 'other.dart'; import 'another.drift'; CREATE TABLE tbl ( id INT NOT NULL PRIMARY KEY AUTOINCREMENT, -- this is a single-line comment place VARCHAR REFERENCES other(location) AS "placeRef" ) AS RowName; all: SELECT /* COUNT(*), */ * FROM tbl WHERE $predicate; @special: SELECT * FROM tbl; typeHints(REQUIRED :foo AS TEXT OR NULL, $predicate = TRUE): SELECT :foo WHERE $predicate; nested AS MyResultSet: SELECT foo.** AS fooRename FROM tbl foo; add: INSERT INTO tbl $row RETURNING *; '''; void main() { test('parses drift files', () { testDriftFile( content, DriftFile([ ImportStatement('other.dart'), ImportStatement('another.drift'), CreateTableStatement( tableName: 'tbl', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INT', constraints: [ NotNull(null), PrimaryKeyColumn(null, autoIncrement: true), ], ), ColumnDefinition( columnName: 'place', typeName: 'VARCHAR', constraints: [ ForeignKeyColumnConstraint( null, ForeignKeyClause( foreignTable: TableReference('other'), columnNames: [ Reference(columnName: 'location'), ], ), ), DriftDartName(null, identifier('placeRef')), ], ), ], driftTableName: DriftTableName( overriddenDataClassName: 'RowName', useExistingDartClass: false, ), ), DeclaredStatement( SimpleName('all'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), where: DartExpressionPlaceholder(name: 'predicate'), ), ), DeclaredStatement( SpecialStatementIdentifier('special'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), DeclaredStatement( SimpleName('typeHints'), SelectStatement( columns: [ ExpressionResultColumn( expression: ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), ), ], where: DartExpressionPlaceholder(name: 'predicate'), ), parameters: [ VariableTypeHint( ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), 'TEXT', orNull: true, isRequired: true, ), DartPlaceholderDefaultValue( 'predicate', BooleanLiteral(true), ), ], ), DeclaredStatement( SimpleName('nested'), SelectStatement( columns: [ NestedStarResultColumn( tableName: 'foo', as: 'fooRename', ) ], from: TableReference('tbl', as: 'foo'), ), as: DriftTableName( overriddenDataClassName: 'MyResultSet', useExistingDartClass: false, ), ), DeclaredStatement( SimpleName('add'), InsertStatement( table: TableReference('tbl'), source: DartInsertablePlaceholder(name: 'row'), targetColumns: const [], returning: Returning([ StarResultColumn(), ]), ), ) ]), ); }); test('parses transaction blocks', () { testDriftFile( ''' test: BEGIN UPDATE foo SET bar = baz; DELETE FROM t; END; ''', DriftFile([ DeclaredStatement( SimpleName('test'), TransactionBlock( begin: BeginTransactionStatement(), innerStatements: [ UpdateStatement( table: TableReference('foo'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'bar'), expression: Reference(columnName: 'baz'), ), ], ), DeleteStatement(from: TableReference('t')), ], commit: CommitStatement(), ), ), ]), ); }); test("reports error when the statement can't be parsed", () { // regression test for https://github.com/simolus3/drift/issues/280#issuecomment-570789454 final parsed = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parseDriftFile('name: NSERT INTO foo DEFAULT VALUES;'); expect( parsed.errors, contains(const TypeMatcher().having( (e) => e.message, 'message', contains('Expected a sql statement here'), )), ); final root = parsed.rootNode as DriftFile; expect( root.allDescendants, isNot(contains(const TypeMatcher())), ); }); test('syntax errors contain correct position', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())); final result = engine.parseDriftFile(''' worksByComposer: SELECT DISTINCT A.* FROM works A, works B ON A.id = WHERE A.composer = :id OR B.composer = :id; '''); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.token.lexeme, 'token.lexeme', 'WHERE')); }); test('parses REQUIRED without type hint', () { final variable = ColonVariableToken(fakeSpan(':category'), ':category'); testDriftFile( 'test(REQUIRED :category): SELECT :category;', DriftFile([ DeclaredStatement( SimpleName('test'), SelectStatement(columns: [ ExpressionResultColumn( expression: ColonNamedVariable(variable), ), ]), parameters: [ VariableTypeHint( ColonNamedVariable(variable), null, isRequired: true, ), ], ), ]), ); }); test('allows statements to appear in any order', () { final result = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parseDriftFile(''' CREATE TABLE foo ( a INTEGER NOT NULL ); import 'b.dart'; a: SELECT * FROM foo; CREATE INDEX x ON foo (a); '''); expect(result.errors, isEmpty); }); test('declared statements can use existing classes syntax', () { testDriftFile( 'foo WITH ExistingDartClass.c: SELECT 1;', DriftFile([ DeclaredStatement( SimpleName('foo'), as: DriftTableName( overriddenDataClassName: 'ExistingDartClass', constructorName: 'c', useExistingDartClass: true, ), SelectStatement( columns: [ ExpressionResultColumn(expression: NumericLiteral(1)), ], ), ), ]), ); }); } test/parser/multiple_statements_test.dart 644 0 0 11452 14612235271 17200 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('can parse multiple statements', () { const sql = 'a: UPDATE tbl SET a = b; b: SELECT * FROM tbl;'; testDriftFile( sql, DriftFile([ DeclaredStatement( SimpleName('a'), UpdateStatement( table: TableReference('tbl'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'a'), expression: Reference(columnName: 'b'), ), ], ), ), DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ]), ); }); test('recovers from invalid statements', () { const sql = 'a: UPDATE tbl SET a = * d; b: SELECT * FROM tbl;'; final tokens = Scanner(sql).scanTokens(); final statements = Parser(tokens).driftFile().statements; expect(statements, hasLength(1)); enforceEqual( statements[0], DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ); }); test('parses imports and declared statements in drift mode', () { const sql = r''' import 'test.dart'; query: SELECT * FROM tbl; '''; final tokens = Scanner(sql, scanDriftTokens: true).scanTokens(); final statements = Parser(tokens, useDrift: true).driftFile().statements; expect(statements, hasLength(2)); final parsedImport = statements[0] as ImportStatement; enforceEqual(parsedImport, ImportStatement('test.dart')); expect(parsedImport.importToken, tokens[0]); expect(parsedImport.importString, tokens[1]); expect(parsedImport.semicolon, tokens[2]); final declared = statements[1] as DeclaredStatement; enforceEqual( declared, DeclaredStatement( SimpleName('query'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ); }); test('parses multiple statements with parseMultiple()', () { const sql = ''' CREATE TABLE users ( id INTEGER PRIMARY KEY, name TEXT, email TEXT ); SELECT * FROM users WHERE id = 1; INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com'); '''; final engine = SqlEngine(); final ast = engine.parseMultiple(sql).rootNode; enforceHasSpan(ast); enforceEqual( ast, SemicolonSeparatedStatements( [ CreateTableStatement( tableName: 'users', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [PrimaryKeyColumn(null)], ), ColumnDefinition(columnName: 'name', typeName: 'TEXT'), ColumnDefinition(columnName: 'email', typeName: 'TEXT'), ], ), SelectStatement( columns: [StarResultColumn()], from: TableReference('users'), where: BinaryExpression( Reference(columnName: 'id'), token(TokenType.equal), NumericLiteral(1), ), ), InsertStatement( table: TableReference('users'), targetColumns: [ Reference(columnName: 'name'), Reference(columnName: 'email') ], source: ValuesSource([ Tuple(expressions: [ StringLiteral('John Doe'), StringLiteral('john@example.com'), ]), ]), ), ], ), ); }); test('parseMultiple reports spans for invalid statements', () { const sql = ''' UPDATE users SET foo = bar; ALTER TABLE this syntax is not yet supported; SELECT * FROM users; '''; final engine = SqlEngine(); final ast = engine.parseMultiple(sql).rootNode; enforceHasSpan(ast); final statements = ast.childNodes.toList(); expect(statements, hasLength(3)); expect( statements[0], isA() .having((e) => e.span?.text, 'span', 'UPDATE users SET foo = bar;'), ); expect( statements[1], isA().having((e) => e.span?.text, 'span', 'ALTER TABLE this syntax is not yet supported;'), ); expect( statements[2], isA() .having((e) => e.span?.text, 'span', 'SELECT * FROM users;'), ); }); } test/parser/create_table_test.dart 644 0 0 22445 14612235271 15514 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../common_data.dart'; import 'utils.dart'; void main() { test('parsers simple create table statements', () { testStatement( 'CREATE TABLE my_tbl (a INT, b TEXT)', CreateTableStatement(tableName: 'my_tbl', columns: [ ColumnDefinition(columnName: 'a', typeName: 'INT'), ColumnDefinition(columnName: 'b', typeName: 'TEXT'), ]), ); }); test('parses complex CREATE TABLE statements', () { testStatement( createTableStmt, CreateTableStatement( tableName: 'users', ifNotExists: true, withoutRowId: false, columns: [ ColumnDefinition( columnName: 'id', typeName: 'INT', constraints: [ NotNull(null), PrimaryKeyColumn( null, autoIncrement: true, onConflict: ConflictClause.rollback, mode: OrderingMode.descending, ), ], ), ColumnDefinition( columnName: 'email', typeName: 'VARCHAR', constraints: [ NotNull(null), UniqueColumn(null, ConflictClause.abort), ], ), ColumnDefinition( columnName: 'score', typeName: 'INT', constraints: [ NotNull('score set'), Default(null, NumericLiteral(420)), CheckColumn( null, BinaryExpression( Reference(columnName: 'score'), token(TokenType.more), NumericLiteral(0), ), ), ], ), ColumnDefinition( columnName: 'display_name', typeName: 'VARCHAR', constraints: [ NullColumnConstraint(null), CollateConstraint( null, 'BINARY', ), ForeignKeyColumnConstraint( null, ForeignKeyClause( foreignTable: TableReference('some'), columnNames: [Reference(columnName: 'thing')], onUpdate: ReferenceAction.cascade, onDelete: ReferenceAction.setNull, deferrable: DeferrableClause( false, InitialDeferrableMode.deferred, ), ), ), ], ) ], tableConstraints: [ KeyClause( null, isPrimaryKey: false, columns: [ IndexedColumn(Reference(columnName: 'score')), IndexedColumn(Reference(columnName: 'display_name')), ], onConflict: ConflictClause.abort, ), ForeignKeyTableConstraint( null, columns: [ Reference(columnName: 'id'), Reference(columnName: 'email'), ], clause: ForeignKeyClause( foreignTable: TableReference('another'), columnNames: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], onDelete: ReferenceAction.noAction, onUpdate: ReferenceAction.restrict, deferrable: DeferrableClause( true, InitialDeferrableMode.immediate, ), ), ) ], ), ); }); test('parses KEY ORDERING in PRIMARY KEY clause', () { testStatement( 'CREATE TABLE a (b TEXT, PRIMARY KEY (b DESC))', CreateTableStatement( tableName: 'a', columns: [ColumnDefinition(columnName: 'b', typeName: 'TEXT')], tableConstraints: [ KeyClause( null, isPrimaryKey: true, columns: [ IndexedColumn( Reference(columnName: 'b'), OrderingMode.descending, ), ], ), ], ), ); }); test('parses GENERATED AS', () { final expr = FunctionExpression( name: 'UPPER', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'a')], ), ); testStatement( ''' CREATE TABLE a ( a TEXT, b TEXT GENERATED ALWAYS AS (UPPER(a)) STORED, c TEXT GENERATED ALWAYS AS (UPPER(a)) VIRTUAL, d TEXT GENERATED ALWAYS AS (UPPER(a)) ) ''', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'a', typeName: 'TEXT'), ColumnDefinition(columnName: 'b', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: true), ]), ColumnDefinition(columnName: 'c', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: false), ]), ColumnDefinition(columnName: 'd', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: false), ]) ], ), ); }); test('parses MAPPED BY constraints when in drift mode', () { testStatement( 'CREATE TABLE a (b NOT NULL MAPPED BY `Mapper()` PRIMARY KEY)', CreateTableStatement(tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: null, constraints: [ NotNull(null), MappedBy(null, inlineDart('Mapper()')), PrimaryKeyColumn(null), ], ), ]), driftMode: true, ); }); test('parses JSON KEY constraints in drift mode', () { testStatement( 'CREATE TABLE a (b INTEGER JSON KEY "my_json_key")', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: 'INTEGER', constraints: [ JsonKey( null, identifier('my_json_key'), ), ], ), ], ), driftMode: true, ); }); test('parses CREATE TABLE WITH in drift mode', () { testStatement( 'CREATE TABLE a (b INTEGER) WITH MyExistingClass', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: 'INTEGER', ), ], driftTableName: DriftTableName( overriddenDataClassName: 'MyExistingClass', useExistingDartClass: true, ), ), driftMode: true, ); }); test('parses custom types in drift mode', () { testStatement( 'CREATE TABLE a (b `PgTypes.uuid` NOT NULL)', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: '`PgTypes.uuid`', constraints: [NotNull(null)], ), ], ), driftMode: true, ); }); test('parses CREATE VIRTUAL TABLE statement', () { testStatement( 'CREATE VIRTUAL TABLE IF NOT EXISTS foo USING bar(a, b(), c) AS drift', CreateVirtualTableStatement( ifNotExists: true, tableName: 'foo', moduleName: 'bar', arguments: [ fakeSpan('a'), fakeSpan('b()'), fakeSpan('c'), ], driftTableName: DriftTableName( overriddenDataClassName: 'drift', useExistingDartClass: false, ), ), driftMode: true, ); }); test('parses CREATE VIRTUAL TABLE statement without args', () { testStatement( 'CREATE VIRTUAL TABLE foo USING bar;', CreateVirtualTableStatement( tableName: 'foo', moduleName: 'bar', arguments: [], ), ); }); test("can't have empty arguments in CREATE VIRTUAL TABLE", () { final engine = SqlEngine(); expect( engine.parse('CREATE VIRTUAL TABLE foo USING bar(a,)').errors, contains( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at closing bracket', ')'), ), ); expect( engine.parse('CREATE VIRTUAL TABLE foo USING bar(a,,b)').errors, contains( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at next comma', ','), ), ); }); test('parses WITHOUT ROWID and STRICT', () { testStatement( 'CREATE TABLE a (c INTEGER) STRICT, WITHOUT ROWID, STRICT', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'c', typeName: 'INTEGER'), ], withoutRowId: true, isStrict: true, ), ); }); test('parses DEFAULT with a negative literal', () { // regression test for https://github.com/simolus3/drift/discussions/1550 testStatement( 'CREATE TABLE a (b INTEGER NOT NULL DEFAULT -1);', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'b', typeName: 'INTEGER', constraints: [ NotNull(null), Default( null, UnaryExpression( Token(TokenType.minus, fakeSpan('-')), NumericLiteral(1), ), ) ]) ], ), ); }); } test/parser/expression_test.dart 644 0 0 14613 14623415614 15302 0ustar0 pubpubimport 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map _testCases = { '3 * 7 + 1 NOT BETWEEN 31 AND 74': BetweenExpression( not: true, check: BinaryExpression( BinaryExpression( NumericLiteral(3), token(TokenType.star), NumericLiteral(7), ), token(TokenType.plus), NumericLiteral(1), ), lower: NumericLiteral(31), upper: NumericLiteral(74), ), '3 * 4 + 5 == COUNT(*)': BinaryExpression( BinaryExpression( BinaryExpression( NumericLiteral(3), token(TokenType.star), NumericLiteral(4), ), token(TokenType.plus), NumericLiteral(5), ), token(TokenType.doubleEqual), FunctionExpression( name: 'COUNT', parameters: StarFunctionParameter(), ), ), '? * ?3 + ?2 == :test': BinaryExpression( BinaryExpression( BinaryExpression( NumberedVariable(null), token(TokenType.star), NumberedVariable(3), ), token(TokenType.plus), NumberedVariable(2), ), token(TokenType.doubleEqual), ColonNamedVariable(ColonVariableToken(fakeSpan(':test'), ':test')), ), 'CASE x WHEN a THEN b WHEN c THEN d ELSE e END': CaseExpression( base: Reference(columnName: 'x'), whens: [ WhenComponent( when: Reference(columnName: 'a'), then: Reference(columnName: 'b'), ), WhenComponent( when: Reference(columnName: 'c'), then: Reference(columnName: 'd'), ), ], elseExpr: Reference(columnName: 'e'), ), 'CASE WHEN a THEN ' 'CASE WHEN b THEN c ELSE d END ' 'ELSE ' 'CASE WHEN e THEN f ELSE g END ' 'END': CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'a'), then: CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'b'), then: Reference(columnName: 'c'), ), ], elseExpr: Reference(columnName: 'd'), ), ), ], elseExpr: CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'e'), then: Reference(columnName: 'f'), ), ], elseExpr: Reference(columnName: 'g'), ), ), "x NOT LIKE '%A%\$' ESCAPE '\$'": StringComparisonExpression( not: true, left: Reference(columnName: 'x'), operator: token(TokenType.like), right: StringLiteral('%A%\$'), escape: StringLiteral('\$'), ), 'NOT EXISTS (SELECT * FROM demo)': UnaryExpression( token(TokenType.not), ExistsExpression( select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('demo'), ), ), ), '(SELECT x)': SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'x'), ), ], ), ), "'hello' || 'world' COLLATE NOCASE": BinaryExpression( StringLiteral('hello'), token(TokenType.doublePipe), CollateExpression( operator: token(TokenType.collate), inner: StringLiteral('world'), collateFunction: token(TokenType.identifier), ), ), 'x in ?': InExpression( left: Reference(columnName: 'x'), inside: NumberedVariable(null), ), 'x IN (SELECT col FROM tbl)': InExpression( left: Reference(columnName: 'x'), inside: SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'col'), ) ], from: TableReference('tbl'), ), ), ), 'x IN (1, 2, (SELECT 3))': InExpression( left: Reference(columnName: 'x'), inside: Tuple( expressions: [ NumericLiteral(1.0), NumericLiteral(2.0), SubQuery( select: SelectStatement(columns: [ ExpressionResultColumn( expression: NumericLiteral(3.0), ), ]), ), ], ), ), 'x IN json_each(bar)': InExpression( left: Reference(columnName: 'x'), inside: TableValuedFunction( 'json_each', ExprFunctionParameters( parameters: [ Reference(columnName: 'bar'), ], ), ), ), 'x NOT IN "table"': InExpression( not: true, left: Reference(columnName: 'x'), inside: TableReference('table'), ), 'CAST(3 + 4 AS TEXT)': CastExpression( BinaryExpression( NumericLiteral(3.0), token(TokenType.plus), NumericLiteral(4.0), ), 'TEXT', ), 'foo ISNULL': IsNullExpression(Reference(columnName: 'foo')), 'foo NOTNULL': IsNullExpression(Reference(columnName: 'foo'), true), 'CURRENT_TIME': TimeConstantLiteral(TimeConstantKind.currentTime), 'CURRENT_TIMESTAMP': TimeConstantLiteral(TimeConstantKind.currentTimestamp), 'CURRENT_DATE': TimeConstantLiteral(TimeConstantKind.currentDate), '(1, 2, 3) > (?, ?, ?)': BinaryExpression( Tuple(expressions: [ for (var i = 1; i <= 3; i++) NumericLiteral(i), ]), token(TokenType.more), Tuple(expressions: [ NumberedVariable(null), NumberedVariable(null), NumberedVariable(null), ]), ), 'RAISE(IGNORE)': RaiseExpression(RaiseKind.ignore), "RAISE(ROLLBACK, 'Not allowed')": RaiseExpression(RaiseKind.rollback, 'Not allowed'), 'foo': Reference(columnName: 'foo'), 'foo.bar': Reference(entityName: 'foo', columnName: 'bar'), 'foo.bar.baz': Reference( schemaName: 'foo', entityName: 'bar', columnName: 'baz', ), 'foo IS DISTINCT FROM bar': IsExpression( false, Reference(columnName: 'foo'), Reference(columnName: 'bar'), distinctFromSyntax: true, ), 'foo IS NOT DISTINCT FROM bar': IsExpression( true, Reference(columnName: 'foo'), Reference(columnName: 'bar'), distinctFromSyntax: true, ), }; void main() { group('expresssion test cases', () { _testCases.forEach((sql, expected) { test(sql, () { final scanner = Scanner(sql); final tokens = scanner.scanTokens(); final parser = Parser(tokens); final expression = parser.expression(); enforceHasSpan(expression); enforceEqual(expression, expected); }); }); }); } test/parser/inline_dart_test.dart 644 0 0 3327 14354621567 15362 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses limit components', () { testStatement( r'SELECT * FROM tbl LIMIT $limit', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), limit: DartLimitPlaceholder(name: 'limit'), ), driftMode: true, ); }); test('parses limit count as expressions', () { testStatement( r'SELECT * FROM tbl LIMIT $amount OFFSET 3', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), limit: Limit( count: DartExpressionPlaceholder(name: 'amount'), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(3), ), ), driftMode: true, ); }); test('parses ordering terms and ordering expressions', () { testStatement( r'SELECT * FROM tbl ORDER BY $term, $expr DESC', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), orderBy: OrderBy( terms: [ DartOrderingTermPlaceholder(name: 'term'), OrderingTerm( expression: DartExpressionPlaceholder(name: 'expr'), orderingMode: OrderingMode.descending, ), ], ), ), driftMode: true, ); }); test('parses full order by placeholders', () { testStatement( r'SELECT * FROM tbl ORDER BY $order', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), orderBy: DartOrderByPlaceholder(name: 'order'), ), driftMode: true, ); }); } test/parser/regression_978_test.dart 644 0 0 1532 14345646642 15656 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses CREATE TABLE statement', () { testStatement( 'CREATE TABLE "sample_table" (' 'id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, sample VARCHAR NULL)', CreateTableStatement( tableName: 'sample_table', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [ NotNull(null), PrimaryKeyColumn(null, autoIncrement: true), ], ), ColumnDefinition( columnName: 'sample', typeName: 'VARCHAR', constraints: [ NullColumnConstraint(null), ], ), ], ), driftMode: true, ); }); } test/parser/insert_test.dart 644 0 0 14313 14612235271 14401 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses insert statements', () { testStatement( 'INSERT OR REPLACE INTO tbl (a, b, c) VALUES (d, e, f)', InsertStatement( mode: InsertMode.insertOrReplace, table: TableReference('tbl'), targetColumns: [ Reference(columnName: 'a'), Reference(columnName: 'b'), Reference(columnName: 'c'), ], source: ValuesSource([ Tuple(expressions: [ Reference(columnName: 'd'), Reference(columnName: 'e'), Reference(columnName: 'f'), ]), ]), ), ); }); test('insert statement with default values', () { testStatement( 'INSERT INTO tbl DEFAULT VALUES', InsertStatement( mode: InsertMode.insert, table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), ), ); }); test('insert statement with select as source', () { testStatement( 'REPLACE INTO tbl SELECT * FROM tbl', InsertStatement( mode: InsertMode.replace, table: TableReference('tbl'), targetColumns: const [], source: SelectInsertSource( SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ), ); }); group('parses upsert clauses', () { const prefix = 'INSERT INTO tbl DEFAULT VALUES ON CONFLICT'; test('without listing indexed columns', () { testStatement( '$prefix DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause([UpsertClauseEntry(action: DoNothing())]), ), ); }); test('listing indexed columns without where clause', () { testStatement( '$prefix (foo, bar DESC) DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [ IndexedColumn(Reference(columnName: 'foo')), IndexedColumn( Reference(columnName: 'bar'), OrderingMode.descending, ), ], action: DoNothing(), ), ], ), ), ); }); test('listing indexed columns and where clause', () { testStatement( '$prefix (foo, bar) WHERE 2 = foo DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [ IndexedColumn(Reference(columnName: 'foo')), IndexedColumn(Reference(columnName: 'bar')), ], where: BinaryExpression( NumericLiteral(2), token(TokenType.equal), Reference(columnName: 'foo'), ), action: DoNothing(), ), ], ), ), ); }); test('having an update action without where', () { testStatement( '$prefix DO UPDATE SET foo = 2', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( action: DoUpdate( [ SingleColumnSetComponent( column: Reference(columnName: 'foo'), expression: NumericLiteral(2), ), ], ), ), ], ), ), ); }); test('having an update action with where', () { testStatement( '$prefix DO UPDATE SET foo = 2 WHERE ?', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( action: DoUpdate( [ SingleColumnSetComponent( column: Reference(columnName: 'foo'), expression: NumericLiteral(2), ), ], where: NumberedVariable(null), ), ), ], ), ), ); }); test('having more than one clause', () { testStatement( '$prefix (foo) DO NOTHING ON CONFLICT (bar) DO UPDATE SET x = 2', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [IndexedColumn(Reference(columnName: 'foo'))], action: DoNothing(), ), UpsertClauseEntry( onColumns: [IndexedColumn(Reference(columnName: 'bar'))], action: DoUpdate( [ SingleColumnSetComponent( column: Reference(columnName: 'x'), expression: NumericLiteral(2), ), ], ), ), ], ), ), ); }); }); test('parses RETURNING clause', () { testStatement( 'INSERT INTO tbl DEFAULT VALUES RETURNING foo, 3, bar;', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), returning: Returning([ ExpressionResultColumn(expression: Reference(columnName: 'foo')), ExpressionResultColumn( expression: NumericLiteral(3), ), ExpressionResultColumn(expression: Reference(columnName: 'bar')), ]), ), ); }); } test/parser/misc_test.dart 644 0 0 1730 14345646642 14022 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { group('BEGIN', () { test('without mode', () { testStatement('BEGIN;', BeginTransactionStatement()); testStatement('BEGIN TRANSACTION;', BeginTransactionStatement()); }); test('deferred', () { testStatement('BEGIN DEFERRED;', BeginTransactionStatement(TransactionMode.deferred)); }); test('immediate', () { testStatement('BEGIN IMMEDIATE;', BeginTransactionStatement(TransactionMode.immediate)); }); test('exclusive', () { testStatement('BEGIN EXCLUSIVE TRANSACTION;', BeginTransactionStatement(TransactionMode.exclusive)); }); }); test('COMMIT', () { testStatement('COMMIT', CommitStatement()); testStatement('END', CommitStatement()); testStatement('COMMIT TRANSACTION', CommitStatement()); testStatement('END TRANSACTION', CommitStatement()); }); } test/parser/create_view_test.dart 644 0 0 10125 14623415614 15372 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses a simple create view statement', () { testStatement( 'CREATE VIEW my_view AS SELECT * FROM my_tbl', CreateViewStatement( viewName: 'my_view', query: SelectStatement( columns: [StarResultColumn()], from: TableReference('my_tbl'), ), ), ); }); test('parses a CREATE VIEW statement with an existing Dart class', () { testStatement( 'CREATE VIEW my_view WITH ExistingDartClass AS SELECT 1', CreateViewStatement( viewName: 'my_view', query: SelectStatement( columns: [ ExpressionResultColumn(expression: NumericLiteral(1)), ], ), driftTableName: DriftTableName( overriddenDataClassName: 'ExistingDartClass', useExistingDartClass: true, ), ), driftMode: true, ); }); test('parses a CREATE VIEW statement with a custom Dart name', () { testStatement( 'CREATE VIEW my_view AS DartClass AS SELECT 1', CreateViewStatement( viewName: 'my_view', query: SelectStatement( columns: [ ExpressionResultColumn(expression: NumericLiteral(1)), ], ), driftTableName: DriftTableName( overriddenDataClassName: 'DartClass', useExistingDartClass: false, ), ), driftMode: true, ); }); test('parses a complex CREATE View statement', () { testStatement( 'CREATE VIEW IF NOT EXISTS my_complex_view (ids, name, count, type) AS ' 'SELECT group_concat(id), name, count(*),\'dog\' FROM dogs GROUP BY name' ' UNION ' 'SELECT group_concat(id), name, count(*),\'cat\' FROM cats GROUP BY name', CreateViewStatement( viewName: 'my_complex_view', columns: ['ids', 'name', 'count', 'type'], ifNotExists: true, query: CompoundSelectStatement( base: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'group_concat', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'id')], ), ), ), ExpressionResultColumn( expression: Reference(columnName: 'name'), ), ExpressionResultColumn( expression: FunctionExpression( name: 'count', parameters: StarFunctionParameter(), ), ), ExpressionResultColumn( expression: StringLiteral('dog'), ), ], from: TableReference('dogs'), groupBy: GroupBy( by: [Reference(columnName: 'name')], ), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.union, select: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'group_concat', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'id')], ), ), ), ExpressionResultColumn( expression: Reference(columnName: 'name'), ), ExpressionResultColumn( expression: FunctionExpression( name: 'count', parameters: StarFunctionParameter(), ), ), ExpressionResultColumn(expression: StringLiteral('cat')) ], from: TableReference('cats'), groupBy: GroupBy( by: [Reference(columnName: 'name')], ), ), ) ], ), ), ); }); } test/parser/regression_891_test.dart 644 0 0 3714 14354621567 15653 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; ColonVariableToken _colon(String name) { return ColonVariableToken(fakeSpan(name), name); } void main() { final caseExpr = CaseExpression( whens: [ WhenComponent( when: BinaryExpression( NumericLiteral(1), token(TokenType.equal), ColonNamedVariable(_colon(':isReviewFolderSelected')), ), then: IsExpression( true, Reference(entityName: 'n', columnName: 'nextReviewTime'), NullLiteral(), ), ), ], elseExpr: IsExpression( false, Reference(entityName: 'n', columnName: 'nextReviewTime'), NullLiteral(), ), ); final folderExpr = BinaryExpression( Reference(entityName: 'n', columnName: 'folderId'), token(TokenType.equal), ColonNamedVariable(_colon(':selectedFolderId')), ); test('repro 1', () { testStatement( ''' SELECT * FROM notes n WHERE CASE WHEN 1 = :isReviewFolderSelected THEN n.nextReviewTime IS NOT NULL ELSE n.nextReviewTime IS NULL END and n.folderId = :selectedFolderId; ''', SelectStatement( from: TableReference('notes', as: 'n'), columns: [StarResultColumn()], where: BinaryExpression( caseExpr, token(TokenType.and), folderExpr, ), ), ); }); test('repro 2', () { testStatement( ''' SELECT * FROM notes n WHERE n.folderId = :selectedFolderId and CASE WHEN 1 = :isReviewFolderSelected THEN n.nextReviewTime IS NOT NULL ELSE n.nextReviewTime IS NULL END; ''', SelectStatement( from: TableReference('notes', as: 'n'), columns: [StarResultColumn()], where: BinaryExpression( folderExpr, token(TokenType.and), caseExpr, ), ), ); }); } test/parser/create_index_test.dart 644 0 0 3555 14354621567 15527 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses CREATE INDEX statements', () { testStatement( 'CREATE INDEX foo ON bar (baz, inga) WHERE TRUE', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn(Reference(columnName: 'baz')), IndexedColumn(Reference(columnName: 'inga')), ], where: BooleanLiteral(true), ), ); }); test('with unique and IF NOT EXISTS', () { testStatement( 'CREATE UNIQUE INDEX IF NOT EXISTS foo ON bar (baz);', CreateIndexStatement( unique: true, ifNotExists: true, indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn(Reference(columnName: 'baz')), ], ), ); }); test('can have ordering modes on index expressions', () { testStatement( 'CREATE INDEX foo ON bar (a + b DESC);', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn( BinaryExpression( Reference(columnName: 'a'), token(TokenType.plus), Reference(columnName: 'b'), ), OrderingMode.descending, ), ], ), ); }); test('can have collate expressions', () { testStatement( 'CREATE INDEX foo ON bar (baz COLLATE RTRIM);', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn( CollateExpression( inner: Reference(columnName: 'baz'), operator: token(TokenType.collate), collateFunction: identifier('RTRIM'), ), ), ], ), ); }); } test/parser/select 755 0 0 0 0 11756 5ustar0 pubpubtest/parser/select/generic_test.dart 644 0 0 5544 14623415614 15761 0ustar0 pubpubimport 'package:sqlparser/src/ast/ast.dart'; import 'package:test/scaffolding.dart'; import '../utils.dart'; final Map testCases = { 'SELECT tbl.*, *, 1 as name WHERE 1 ORDER BY name ASC LIMIT 3 OFFSET 5': SelectStatement( columns: [ StarResultColumn('tbl'), StarResultColumn(null), ExpressionResultColumn( expression: NumericLiteral(1), as: 'name', ), ], where: NumericLiteral(1), orderBy: OrderBy(terms: [ OrderingTerm( expression: Reference(columnName: 'name'), orderingMode: OrderingMode.ascending, ), ]), limit: Limit( count: NumericLiteral(3), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(5), ), ), 'SELECT tbl.*, (SELECT * FROM table2) FROM tbl': SelectStatement( columns: [ StarResultColumn('tbl'), ExpressionResultColumn( expression: SubQuery( select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('table2'), ), ), ), ], from: TableReference('tbl'), ), 'SELECT * FROM tbl WHERE id IN ()': SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), where: InExpression( left: Reference(columnName: 'id'), inside: Tuple(expressions: []), ), ), 'SELECT rowid FROM tbl': SelectStatement( columns: [ ExpressionResultColumn(expression: Reference(columnName: 'rowid')), ], from: TableReference('tbl'), ), 'SELECT col IN tbl AS in_tbl': SelectStatement(columns: [ ExpressionResultColumn( expression: InExpression( left: Reference(columnName: 'col'), inside: TableReference('tbl'), ), as: 'in_tbl', ), ]), 'SELECT col IN (SELECT 2) AS in_select': SelectStatement(columns: [ ExpressionResultColumn( expression: InExpression( left: Reference(columnName: 'col'), inside: SubQuery( select: SelectStatement( columns: [ExpressionResultColumn(expression: NumericLiteral(2))], ), ), ), as: 'in_select', ), ]), 'SELECT col IN tbl_valued() AS in_select': SelectStatement(columns: [ ExpressionResultColumn( expression: InExpression( left: Reference(columnName: 'col'), inside: TableValuedFunction( 'tbl_valued', ExprFunctionParameters(parameters: []), ), ), as: 'in_select', ), ]), }; void main() { testAll(testCases); test('supports mapped by columns', () { testStatement( 'SELECT 1 MAPPED BY `foo` AS r', SelectStatement(columns: [ ExpressionResultColumn( expression: NumericLiteral(1), mappedBy: MappedBy(null, inlineDart('foo')), as: 'r', ), ]), driftMode: true, ); }); } test/parser/select/group_by_test.dart 644 0 0 1304 14354621567 16170 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses group by statements', () { final stmt = SqlEngine() .parse("SELECT * FROM test GROUP BY country HAVING country LIKE '%G%'") .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.groupBy!, GroupBy( by: [Reference(columnName: 'country')], having: StringComparisonExpression( left: Reference(columnName: 'country'), operator: token(TokenType.like), right: StringLiteral('%G%'), ), ), ); }); } test/parser/select/nested_query_test.dart 644 0 0 2221 14370670576 17052 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses nested query statements', () { final stmt = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parse('SELECT LIST(SELECT * FROM test) FROM test') .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.columns[0], NestedQueryColumn( select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('test'), ), ), ); }); test('parses nested query statements with as', () { final stmt = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parse('SELECT LIST(SELECT * FROM test) AS newname FROM test') .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.columns[0], NestedQueryColumn( as: 'newname', select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('test'), ), ), ); }); } test/parser/select/from_test.dart 644 0 0 21653 14354621567 15336 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void _enforceFrom(SelectStatement stmt, Queryable expected) { enforceHasSpan(stmt); enforceEqual(stmt.from!, expected); } void main() { group('from', () { test('a simple table', () { final stmt = SqlEngine().parse('SELECT * FROM tbl').rootNode as SelectStatement; _enforceFrom(stmt, TableReference('tbl')); }); test('schema name and alias', () { final stmt = SqlEngine().parse('SELECT * FROM main.tbl foo').rootNode as SelectStatement; _enforceFrom(stmt, TableReference('tbl', schemaName: 'main', as: 'foo')); }); test('from more than one table', () { final stmt = SqlEngine() .parse('SELECT * FROM tbl AS test, table2') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('tbl', as: 'test'), joins: [ Join( operator: JoinOperator.comma(), query: TableReference('table2'), ), ], ), ); }); test('more than one table with ON constraint', () { final stmt = SqlEngine() .parse('SELECT * FROM tbl AS test, table2 ON TRUE') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('tbl', as: 'test'), joins: [ Join( operator: JoinOperator.comma(), query: TableReference('table2'), constraint: OnConstraint( expression: BooleanLiteral(true), ), ), ], ), ); }); test('inner select statements', () { final stmt = SqlEngine() .parse( 'SELECT * FROM table1, (SELECT * FROM table2 WHERE a) as "inner"') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('table1'), joins: [ Join( operator: JoinOperator.comma(), query: SelectStatementAsSource( statement: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('table2'), where: Reference(columnName: 'a'), ), as: 'inner', ), ), ], ), ); }); test('inner compound select statements', () { final stmt = SqlEngine() .parse('SELECT SUM(*) FROM (SELECT COUNT(*) FROM table1 UNION ALL ' 'SELECT COUNT(*) from table2)') .rootNode as SelectStatement; final countStar = ExpressionResultColumn( expression: FunctionExpression( name: 'COUNT', parameters: StarFunctionParameter(), ), ); _enforceFrom( stmt, SelectStatementAsSource( statement: CompoundSelectStatement( base: SelectStatement( columns: [countStar], from: TableReference('table1'), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [countStar], from: TableReference('table2'), ), ), ], ), ), ); }); test('from a join', () { final stmt = SqlEngine() .parse('SELECT * FROM table1 ' 'INNER JOIN table2 USING (test) ' 'LEFT OUTER JOIN table3 ON TRUE') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('table1'), joins: [ Join( operator: JoinOperator(JoinOperatorKind.inner), query: TableReference('table2'), constraint: UsingConstraint(columnNames: ['test']), ), Join( operator: JoinOperator(JoinOperatorKind.left, outer: true), query: TableReference('table3'), constraint: OnConstraint(expression: BooleanLiteral(true)), ), ], ), ); }); test('table valued function', () { testStatement( ''' SELECT DISTINCT user.name FROM user, json_each(user.phone) WHERE json_each.value LIKE '704-%'; ''', SelectStatement( distinct: true, columns: [ ExpressionResultColumn( expression: Reference(entityName: 'user', columnName: 'name'), ), ], from: JoinClause( primary: TableReference('user'), joins: [ Join( operator: JoinOperator.comma(), query: TableValuedFunction( 'json_each', ExprFunctionParameters(parameters: [ Reference(entityName: 'user', columnName: 'phone') ]), ), ), ], ), where: StringComparisonExpression( left: Reference(entityName: 'json_each', columnName: 'value'), operator: token(TokenType.like), right: StringLiteral('704-%'), ), ), ); }); }); group('join kinds', () { SelectStatement selectWith(Queryable from) { return SelectStatement( columns: [StarResultColumn()], from: from, ); } test('comma', () { testStatement( 'SELECT * FROM foo, bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join(operator: JoinOperator.comma(), query: TableReference('bar')) ]), ), ); }); test('none', () { testStatement( 'SELECT * FROM foo JOIN bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join( operator: JoinOperator(JoinOperatorKind.none), query: TableReference('bar')) ]), ), ); }); test('natural none', () { testStatement( 'SELECT * FROM foo NATURAL JOIN bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join( operator: JoinOperator(JoinOperatorKind.none, natural: true), query: TableReference('bar')) ]), ), ); }); test('cross', () { testStatement( 'SELECT * FROM foo CROSS JOIN bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join( operator: JoinOperator(JoinOperatorKind.cross), query: TableReference('bar')) ]), ), ); }); for (final natural in [true, false]) { group('with natural: $natural', () { final naturalText = natural ? 'NATURAL' : ''; test('inner', () { testStatement( 'SELECT * FROM foo $naturalText INNER JOIN bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join( operator: JoinOperator( JoinOperatorKind.inner, natural: natural, ), query: TableReference('bar'), ) ]), ), ); }); for (final outer in [true, false]) { final outerText = outer ? 'OUTER' : ''; const kinds = { 'LEFT': JoinOperatorKind.left, 'RIGHT': JoinOperatorKind.right, 'FULL': JoinOperatorKind.full, }; group('with outer: $outer', () { kinds.forEach((text, operatorKind) { test('operator $text', () { testStatement( 'SELECT * FROM foo $naturalText $text $outerText JOIN bar', selectWith( JoinClause(primary: TableReference('foo'), joins: [ Join( operator: JoinOperator( operatorKind, natural: natural, outer: outer, ), query: TableReference('bar'), ) ]), ), ); }); }); }); } }); } test('does not allow natural with comma', () { expectParseError('SELECT * FROM foo NATURAL, bar', span: ','); }); test('does not allow natural with cross', () { expectParseError('SELECT * FROM foo NATURAL CROSS JOIN bar', span: 'CROSS'); }); test('does not allow INNER OUTER', () { expectParseError('SELECT * FROM foo INNER OUTER CROSS JOIN bar', span: 'OUTER'); }); }); } test/parser/select/order_by_test.dart 644 0 0 2714 14370670576 16157 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses order by clauses', () { final parsed = SqlEngine() .parse('SELECT * FROM tbl ORDER BY -a, b DESC') .rootNode as SelectStatement; enforceHasSpan(parsed); enforceEqual( parsed.orderBy!, OrderBy( terms: [ OrderingTerm( expression: UnaryExpression( token(TokenType.minus), Reference(columnName: 'a'), ), ), OrderingTerm( orderingMode: OrderingMode.descending, expression: Reference(columnName: 'b'), ), ], ), ); }); test('parses clauses with NULLS FIRST or NULLS LAST', () { final parsed = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parse(r'SELECT * FROM tbl ORDER BY $a NULLS LAST, b NULLS FIRST') .rootNode as SelectStatement; enforceHasSpan(parsed); enforceEqual( parsed.orderBy!, OrderBy( terms: [ OrderingTerm( expression: DartExpressionPlaceholder(name: 'a'), nulls: OrderingBehaviorForNulls.last, ), OrderingTerm( expression: Reference(columnName: 'b'), nulls: OrderingBehaviorForNulls.first, ), ], ), ); }); } test/parser/select/values_test.dart 644 0 0 3220 14354621567 15640 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses VALUES select statement', () { testStatement( "VALUES ('foo', 'bar'), (1, 2)", ValuesSelectStatement( [ Tuple( expressions: [ StringLiteral('foo'), StringLiteral('bar'), ], ), Tuple( expressions: [ NumericLiteral(1), NumericLiteral(2), ], ), ], ), ); }); test('can select FROM VALUES', () { testStatement( 'SELECT * FROM (VALUES(1, 2))', SelectStatement( columns: [StarResultColumn()], from: SelectStatementAsSource( statement: ValuesSelectStatement( [ Tuple( expressions: [ NumericLiteral(1), NumericLiteral(2), ], ), ], ), ), ), ); }); test('can use WITH clause on VALUES', () { testStatement( 'WITH foo AS (VALUES (3)) VALUES(1, 2)', ValuesSelectStatement( [ Tuple( expressions: [ NumericLiteral(1), NumericLiteral(2), ], ), ], withClause: WithClause( recursive: false, ctes: [ CommonTableExpression( cteTableName: 'foo', as: ValuesSelectStatement([ Tuple(expressions: [NumericLiteral(3)]), ]), ), ], ), ), ); }); } test/parser/select/common_table_expression_test.dart 644 0 0 5273 14623415614 21262 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses WITH clauses', () { testStatement( ''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; ''', SelectStatement( withClause: WithClause( recursive: true, ctes: [ CommonTableExpression( cteTableName: 'cnt', columnNames: ['x'], as: CompoundSelectStatement( base: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(1), ), ], ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: BinaryExpression( Reference(columnName: 'x'), token(TokenType.plus), NumericLiteral(1), ), ), ], from: TableReference('cnt'), limit: Limit( count: NumericLiteral(1000000), ), ), ), ], ), ), ], ), columns: [ ExpressionResultColumn(expression: Reference(columnName: 'x')), ], from: TableReference('cnt'), ), ); }); test('parses MATERIALIZED / NOT MATERIALIZED clauses', () { testStatement( ''' WITH foo(x) AS MATERIALIZED (SELECT *), bar(x) AS NOT MATERIALIZED (SELECT *) SELECT *; ''', SelectStatement( withClause: WithClause( recursive: false, ctes: [ CommonTableExpression( cteTableName: 'foo', materializationHint: MaterializationHint.materialized, columnNames: ['x'], as: SelectStatement(columns: [StarResultColumn()]), ), CommonTableExpression( cteTableName: 'bar', materializationHint: MaterializationHint.notMaterialized, columnNames: ['x'], as: SelectStatement(columns: [StarResultColumn()]), ), ], ), columns: [StarResultColumn()], ), ); }); } test/parser/select/compound_test.dart 644 0 0 2022 14354621567 16164 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses compound select statements', () { testStatement( 'SELECT * FROM tbl UNION ALL SELECT 1 EXCEPT SELECT 2', CompoundSelectStatement( base: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(1), ), ], ), ), CompoundSelectPart( mode: CompoundSelectMode.except, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(2), ), ], ), ), ], ), ); }); } test/parser/select/limit_test.dart 644 0 0 3026 14354621567 15463 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { group('limit clauses', () { test('with just a limit', () { final select = SqlEngine() .parse('SELECT * FROM test LIMIT 5 * 3') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: BinaryExpression( NumericLiteral(5), token(TokenType.star), NumericLiteral(3), ), ), ); }); test('with offset', () { final select = SqlEngine() .parse('SELECT * FROM test LIMIT 10 OFFSET 2') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: NumericLiteral(10), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(2), ), ); }); test('with offset as comma', () { // with the comma notation, the offset comes first. // https://www.sqlite.org/lang_select.html#limitoffset final select = SqlEngine() .parse('SELECT * FROM test LIMIT 10, 2') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: NumericLiteral(2), offsetSeparator: token(TokenType.comma), offset: NumericLiteral(10), ), ); }); }); } test/parser/update_test.dart 644 0 0 10451 14612235271 14356 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map testCases = { 'UPDATE OR ROLLBACK tbl SET a = NULL, b = c WHERE d': UpdateStatement( or: FailureMode.rollback, table: TableReference('tbl'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'a'), expression: NullLiteral(), ), SingleColumnSetComponent( column: Reference(columnName: 'b'), expression: Reference(columnName: 'c'), ) ], where: Reference(columnName: 'd'), ), }; void main() { group('update statements', () { testAll(testCases); }); test('parses updates with column-name-list and subquery', () { testStatement( ''' UPDATE foo SET (a, b) = (SELECT b, a FROM bar AS b WHERE b.id=foo.id); ''', UpdateStatement(table: TableReference('foo'), set: [ MultiColumnSetComponent( columns: [Reference(columnName: 'a'), Reference(columnName: 'b')], rowValue: SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'b'), ), ExpressionResultColumn( expression: Reference(columnName: 'a'), ), ], from: TableReference('bar', as: 'b'), where: BinaryExpression( Reference(entityName: 'b', columnName: 'id'), token(TokenType.equal), Reference(entityName: 'foo', columnName: 'id'), ), ), ), ) ]), ); }); test('parses updates with column-name-list and scalar rowValues', () { testStatement( ''' UPDATE foo SET (a, b) = (b, 3+4); ''', UpdateStatement(table: TableReference('foo'), set: [ MultiColumnSetComponent( columns: [Reference(columnName: 'a'), Reference(columnName: 'b')], rowValue: Tuple(expressions: [ Reference(columnName: "b"), BinaryExpression( NumericLiteral(3), token(TokenType.plus), NumericLiteral(4)), ], usedAsRowValue: true), ) ]), ); }); test('parses updates with FROM clause', () { testStatement( ''' UPDATE inventory SET quantity = quantity - daily.amt FROM (SELECT sum(quantity) AS amt, itemId FROM sales GROUP BY 2) AS daily WHERE inventory.itemId = daily.itemId; ''', UpdateStatement( table: TableReference('inventory'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'quantity'), expression: BinaryExpression( Reference(columnName: 'quantity'), token(TokenType.minus), Reference(entityName: 'daily', columnName: 'amt'), ), ), ], from: SelectStatementAsSource( statement: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'sum', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'quantity')], ), ), as: 'amt', ), ExpressionResultColumn( expression: Reference(columnName: 'itemId'), ), ], from: TableReference('sales'), groupBy: GroupBy( by: [NumericLiteral(2)], ), ), as: 'daily', ), where: BinaryExpression( Reference(entityName: 'inventory', columnName: 'itemId'), token(TokenType.equal), Reference(entityName: 'daily', columnName: 'itemId'), ), ), ); }); test('parses updates with RETURNING clause', () { testStatement( 'UPDATE tbl SET foo = bar RETURNING *', UpdateStatement( table: TableReference('tbl'), set: [ SingleColumnSetComponent( column: Reference(columnName: 'foo'), expression: Reference(columnName: 'bar'), ), ], returning: Returning([StarResultColumn()]), ), ); }); } test/engine 755 0 0 0 0 10450 5ustar0 pubpubtest/engine/autocomplete 755 0 0 0 0 13151 5ustar0 pubpubtest/engine/autocomplete/static_test.dart 644 0 0 2261 14345646642 17030 0ustar0 pubpubimport 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('suggests a CREATE an empty file', () { final suggestions = completionsFor('^'); expect(suggestions.anchor, 0); expect(suggestions, suggests('CREATE')); }); test('suggests CREATE TABLE completion after CREATE', () async { final suggestions = completionsFor('CREATE ^'); expect(suggestions.anchor, 7); expect(suggestions, suggests('TABLE')); }); test('suggests completions for started keywords', () { final suggestions = completionsFor('creat^'); expect(suggestions.anchor, 0); expect(suggestions, suggests('CREATE')); }); } dynamic hasCode(dynamic code) => SuggestionWithCode(code); class SuggestionWithCode extends Matcher { final Matcher codeMatcher; SuggestionWithCode(dynamic code) : codeMatcher = wrapMatcher(code); @override Description describe(Description description) { return description.add('suggests ').addDescriptionOf(codeMatcher); } @override bool matches(dynamic item, Map matchState) { return item is Suggestion && codeMatcher.matches(item.code, matchState); } } test/engine/autocomplete/utils.dart 644 0 0 3151 14370670576 15642 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; /// Parses the [driftFile] and computes available autocomplete suggestions at /// the position of a `^` character in the source. ComputedSuggestions completionsFor(String driftFile, {void Function(SqlEngine)? setup}) { final position = driftFile.indexOf('^'); final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())); setup?.call(engine); final result = engine.parseDriftFile(driftFile.replaceFirst('^', '')); return result.autoCompleteEngine!.suggestCompletions(position - 1); } Matcher hasCode(String code) => _SuggestionWithCode(code); Matcher suggests(String code) => _SuggestsMatcher(contains(hasCode(code))); Matcher suggestsAll(List codes) { return _SuggestsMatcher(containsAll(codes.map(hasCode))); } class _SuggestionWithCode extends Matcher { final Matcher codeMatcher; _SuggestionWithCode(dynamic code) : codeMatcher = wrapMatcher(code); @override Description describe(Description description) { return description.add('suggests ').addDescriptionOf(codeMatcher); } @override bool matches(dynamic item, Map matchState) { return item is Suggestion && codeMatcher.matches(item.code, matchState); } } class _SuggestsMatcher extends CustomMatcher { _SuggestsMatcher(matcher) : super('Suggestions containing', 'suggestions', matcher); @override List? featureValueOf(dynamic actual) { if (actual is ComputedSuggestions) { return actual.suggestions; } return null; } } test/engine/autocomplete/table_name_test.dart 644 0 0 2410 14345646642 17624 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; import '../../analysis/data.dart'; import 'utils.dart'; void main() { group('suggests table name', () { test('after SELECT FROM', () { expect(_compute('a: SELECT * FROM ^'), suggestsTables); }); test('in join', () { expect(_compute('a: SELECT * FROM demo INNER JOIN ^;'), suggestsTables); }); test('after update', () { expect(_compute('a: UPDATE ^ SET'), suggestsTables); }); test('after insert', () { expect(_compute('a: INSERT INTO ^;'), suggestsTables); }); test('in index', () { final suggestion = _compute('CREATE INDEX IF NOT EXISTS name ON ^ (id)'); expect(suggestion, suggestsTables); }); test('in trigger', () { final suggestion = _compute('CREATE TRIGGER name BEFORE DELETE ON ^'); expect(suggestion, suggestsTables); }); }); } ComputedSuggestions _compute(String driftFile) { return completionsFor(driftFile, setup: _setupEngine); } void _setupEngine(SqlEngine engine) { engine ..registerTable(demoTable) ..registerTable(anotherTable); } Matcher get suggestsTables => suggestsAll(['demo', 'tbl', 'sqlite_master']); test/engine/find_node_by_position_test.dart 644 0 0 1331 14345646642 17400 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('finds the most relevant node', () { final engine = SqlEngine(); final result = engine.parse('SELECT * FROM tbl;'); // | this is offset 8 // | this is offset 17 final mostRelevantAtStar = result.findNodesAtPosition(8); expect(mostRelevantAtStar.length, 1); expect(mostRelevantAtStar.single, const TypeMatcher()); final mostRelevantAtTbl = result.findNodesAtPosition(17, length: 2); expect(mostRelevantAtTbl.length, 1); expect(mostRelevantAtTbl.single, const TypeMatcher()); }); } test/engine/sql_engine_test.dart 644 0 0 6741 14711507160 15157 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; void main() { test('does not throw when parsing invalid statements', () { final engine = SqlEngine(); late ParseResult result; try { result = engine.parse('UDPATE foo SET bar = foo;'); } on ParsingError { fail('Calling engine.parse threw an error'); } expect(result.errors, isNotEmpty); }); test('does not throw when encountering tokenizer errors', () { final engine = SqlEngine(); final result = engine .parse("SELECT * FROM foo WHERE bar = 'unterminated string literal"); expect(result.errors, [isParsingError(message: contains('Unterminated string'))]); }); test('does not throw when analyzing invalid statements', () { final engine = SqlEngine(); late AnalysisContext result; try { result = engine.analyze('UDPATE foo SET bar = foo;'); } on ParsingError { fail('Calling engine.parse threw an error'); } expect(result.errors, isNotEmpty); }); group('parseColumnConstraints', () { test('parses constraints', () { final result = SqlEngine() .parseColumnConstraints('PRIMARY KEY NOT NULL CHECK (1) DEFAULT 0'); final parsedConstraints = (result.rootNode as ColumnDefinition).constraints; final expectedConstraints = [ PrimaryKeyColumn(null), NotNull(null), CheckColumn(null, NumericLiteral(1)), Default(null, NumericLiteral(0)), ]; expect(parsedConstraints, hasLength(expectedConstraints.length)); for (var i = 0; i < expectedConstraints.length; i++) { enforceHasSpan(parsedConstraints[i]); enforceEqual(parsedConstraints[i], expectedConstraints[i]); } }); test('parses until error', () { final result = SqlEngine().parseColumnConstraints( 'PRIMARY KEY NOT NULL invalid syntax CHECK (1)'); final parsedConstraints = (result.rootNode as ColumnDefinition).constraints; expect(parsedConstraints, hasLength(2)); expect(result.errors, [ isA().having( (e) => e.message, 'message', contains('Expected a constraint')), ]); }); test('never allows drift extensions', () { final result = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) .parseColumnConstraints('MAPPED BY `myconverter()`'); expect(result.errors, [ isA().having( (e) => e.message, 'message', contains('Expected a constraint')), ]); }); }); group('parseTableConstraint', () { test('parses constraint', () { final result = SqlEngine().parseTableConstraint( 'CONSTRAINT foo FOREIGN KEY (a, b) REFERENCES c (d, e);'); expect(result.errors, isEmpty); enforceEqual( result.rootNode, ForeignKeyTableConstraint( 'foo', columns: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], clause: ForeignKeyClause( foreignTable: TableReference('c'), columnNames: [ Reference(columnName: 'd'), Reference(columnName: 'e'), ], ), ), ); }); test('report errors', () { final result = SqlEngine().parseTableConstraint('parse error'); expect(result.errors, isNotEmpty); }); }); } test/engine/module 755 0 0 0 0 11735 5ustar0 pubpubtest/engine/module/geopoly_test.dart 644 0 0 1635 14656673450 16011 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; final _geopolyOptions = EngineOptions( enabledExtensions: const [ GeopolyExtension(), ], ); void main() { group('creating geopoly tables', () { final engine = SqlEngine(_geopolyOptions); test('can create geopoly table', () { final result = engine.analyze( '''CREATE VIRTUAL TABLE geo USING geopoly(a integer not null, b integer, c);'''); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'geo'); final columns = table.resultColumns; expect(columns, hasLength(4)); expect(columns[0].type.type, equals(BasicType.blob)); expect(columns[1].type.type, equals(BasicType.int)); expect(columns[2].type.type, equals(BasicType.int)); expect(columns[3].type.type, equals(BasicType.any)); }); }); } test/engine/module/math_test.dart 644 0 0 4012 14345646642 15252 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { final engine = SqlEngine(EngineOptions( version: SqliteVersion.current, enabledExtensions: const [BuiltInMathExtension()], )); ResolveResult resolveExpr(String expr) { final result = engine.analyze('SELECT $expr;'); final column = ((result.root as SelectStatement).columns.single as ExpressionResultColumn) .expression; return result.typeOf(column); } test('refuses to work with old sqlite versions', () { expect( () => SqlEngine(EngineOptions( enabledExtensions: const [BuiltInMathExtension()], )), throwsStateError, ); }); test('reports pi as double', () { expect(resolveExpr('pi()').type?.type, BasicType.real); }); test('reports sin as double', () { expect(resolveExpr('sin(3)').type?.type, BasicType.real); }); test('reports ceil as int', () { expect(resolveExpr('ceil(3.5)').type?.type, BasicType.int); }); test('infers arguments as numeric', () { final result = engine.analyze('SELECT sin(?);'); final variable = result.root.allDescendants.whereType().first; expect(result.typeOf(variable).type?.type, BasicType.real); }); group('checks amount of arguments', () { test('for log', () { expect(engine.analyze('SELECT log(2)').errors, isEmpty); expect(engine.analyze('SELECT log(2, 4)').errors, isEmpty); expect(engine.analyze('SELECT log(2, 4, 8)').errors, isNotEmpty); }); test('for pi', () { expect(engine.analyze('SELECT pi()').errors, isEmpty); expect(engine.analyze('SELECT pi(3)').errors, isNotEmpty); }); test('for radians', () { expect(engine.analyze('SELECT radians(3)').errors, isEmpty); expect(engine.analyze('SELECT radians(3, 4)').errors, isNotEmpty); }); test('for power', () { expect(engine.analyze('SELECT power(3, 4)').errors, isEmpty); expect(engine.analyze('SELECT power(3)').errors, isNotEmpty); }); }); } test/engine/module/json1_test.dart 644 0 0 7643 14656673450 15372 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../../analysis/errors/utils.dart'; void main() { group('json with new type inference', () { final engine = SqlEngine(EngineOptions( enabledExtensions: const [Json1Extension()], version: SqliteVersion.v3_45, )); // add user (name, phone) table final table = engine.schemaReader.read( engine.parse('CREATE TABLE user (name TEXT, phone TEXT)').rootNode as TableInducingStatement, ); engine.registerTable(table); ResolveResult findResult(String expression) { final result = engine.analyze('SELECT $expression;'); final select = result.root as SelectStatement; final column = select.resultSet.resolvedColumns!.single; return result.typeOf(column); } const resolvedString = ResolveResult(ResolvedType(type: BasicType.text)); const resolvedBlob = ResolveResult(ResolvedType(type: BasicType.blob)); test('create json', () { expect(findResult("json('{}')"), resolvedString); expect(findResult("json_array('foo', 'bar')"), resolvedString); expect(findResult("json_insert('{}')"), resolvedString); expect(findResult("json_replace('{}')"), resolvedString); expect(findResult("json_set('{}')"), resolvedString); expect(findResult('json_object()'), resolvedString); expect(findResult("json_patch('{}', '{}')"), resolvedString); expect(findResult("json_remove('{}', '{}')"), resolvedString); expect(findResult("json_quote('foo')"), resolvedString); expect(findResult('json_group_array()'), resolvedString); expect(findResult('json_group_object()'), resolvedString); expect(findResult('json_pretty(?)'), resolvedString); }); test('create binary json', () { expect(findResult("jsonb('{}')"), resolvedBlob); expect(findResult("jsonb_array('foo', 'bar')"), resolvedBlob); expect(findResult("jsonb_insert('{}')"), resolvedBlob); expect(findResult("jsonb_replace('{}')"), resolvedBlob); expect(findResult("jsonb_set('{}')"), resolvedBlob); expect(findResult('jsonb_object()'), resolvedBlob); expect(findResult("jsonb_patch('{}', '{}')"), resolvedBlob); expect(findResult("jsonb_remove('{}', '{}')"), resolvedBlob); expect(findResult('jsonb_group_array()'), resolvedBlob); expect(findResult('jsonb_group_object()'), resolvedBlob); }); test('json_type', () { expect( findResult("json_type('foo', 'bar')"), const ResolveResult(ResolvedType(type: BasicType.text, nullable: true)), ); }); test('json_valid', () { expect( findResult('json_valid()'), const ResolveResult(ResolvedType.bool())); }); test('json_extract', () { expect(findResult('json_extract()'), const ResolveResult.unknown()); }); test('json_array_length', () { expect( findResult('json_array_length()'), const ResolveResult(ResolvedType(type: BasicType.int)), ); }); test('can use table-valued functions', () { final result = engine.analyze(''' SELECT DISTINCT user.name FROM user, json_each(user.phone) WHERE json_each.value LIKE '704-%'; '''); expect(result.errors, isEmpty); }); }); test('does not allow jsonb functions before 3.45', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_44)); final result = engine.analyze('SELECT jsonb(?);'); expect(result.errors, [ analysisErrorWith( lexeme: 'jsonb', type: AnalysisErrorType.unknownFunction, ) ]); }); test('does not allow json_pretty before 3.46', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_45)); final result = engine.analyze('SELECT json_pretty(?);'); expect(result.errors, [ analysisErrorWith( lexeme: 'json_pretty', type: AnalysisErrorType.notSupportedInDesiredVersion, ) ]); }); } test/engine/module/fts5_test.dart 644 0 0 26213 14711507160 15215 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../../analysis/data.dart'; final _fts5Options = EngineOptions(enabledExtensions: const [Fts5Extension()]); void main() { group('creating fts5 tables', () { final engine = SqlEngine(_fts5Options); test('can create fts5 tables', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii')"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(1)); expect(columns.single.name, 'bar'); expect( table, isA() .having((e) => e.contentTable, 'contentTable', null) .having((e) => e.contentRowId, 'contentRowId', null), ); }); test('can create fts5 tables with content table', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii',content=tbl, content_rowid=d)"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); expect(table.resultColumns, [isA().having((c) => c.name, 'name', 'bar')]); expect(table.findColumn('oid'), isA()); expect( table, isA() .having((e) => e.contentTable, 'contentTable', 'tbl') .having((e) => e.contentRowId, 'contentRowId', 'd'), ); }); test('does clean option values', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii', content='tbl', content_rowid='d')"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect( table, isA() .having((e) => e.contentTable, 'contentTable', 'tbl') .having((e) => e.contentRowId, 'contentRowId', 'd'), ); }); test('detects empty content table', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii',content='', content_rowid='d')"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect( table, isA() .having((e) => e.contentTable, 'contentTable', null) .having((e) => e.contentRowId, 'contentRowId', null), ); }); test('content table undefined rowid falls back', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii',content='tbl')"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect( table, isA() .having((e) => e.contentTable, 'contentTable', 'tbl') .having((e) => e.contentRowId, 'contentRowId', 'rowid'), ); }); group('creating fts5vocab tables', () { final engine = SqlEngine(_fts5Options); test('can create fts5vocab instance table', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5vocab(bar, instance)'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(4)); expect(columns.map((e) => e.name), contains('offset')); }); test('can create fts5vocab row table', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5vocab(bar, row)'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(3)); }); test('can create fts5vocab col table', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5vocab(bar, col)'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(4)); expect(columns.map((e) => e.name), contains('col')); }); }); test('handles the UNINDEXED column option', () { final result = engine .analyze('CREATE VIRTUAL TABLE foo USING fts5(bar, baz UNINDEXED)'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); expect(table.resultColumns.map((c) => c.name), ['bar', 'baz']); }); }); group('type inference for function calls', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); test('return type of bm25()', () { final result = engine .analyze('SELECT *, bm25(foo) AS b FROM foo WHERE foo MATCH \'\''); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.real))); expect(result.typeOf((column as ExpressionColumn).expression), const ResolveResult(ResolvedType(type: BasicType.real))); }); test('return type of highlight()', () { final result = engine.analyze("SELECT *, highlight(foo, 0, '', '') AS b " "FROM foo WHERE foo MATCH ''"); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.text))); }); test('return type of snippet()', () { final result = engine .analyze("SELECT *, snippet(foo, 0, '', '', '...', 20) AS b " "FROM foo WHERE foo MATCH ''"); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.text))); }); }); group('type inference for function arguments', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE fts USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); void checkVarTypes(String sql, List expected) { final result = engine.analyze(sql); expect(result.errors, isEmpty); final foundVars = result.root.allDescendants.whereType(); expect( foundVars.map((Typeable t) => result.typeOf(t).type!.type), expected, ); } test('for highlight()', () { checkVarTypes( 'SELECT highlight(fts, ?, ?, ?) FROM fts;', [ BasicType.int, // column index BasicType.text, // text before phrase match BasicType.text, // text after phrase match ], ); }); test('for snippet()', () { checkVarTypes( 'SELECT snippet(fts, ?, ?, ?, ?, ?) FROM fts;', [ BasicType.int, // column index BasicType.text, // text before match BasicType.text, // text after match BasicType.text, // text to add match isn't at start BasicType.int, // maximum number of tokens ], ); }); test('for bm25', () { checkVarTypes( 'SELECT bm25(fts, ?, ?) FROM fts;', [ BasicType.real, BasicType.real, ], ); }); }); group('error reporting', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); final normalResult = engine.analyze('CREATE TABLE other (bar TEXT);'); engine.registerTable(const SchemaFromCreateTable() .read(normalResult.root as TableInducingStatement)); }); Matcher hasMessage(Object msgMatcher) { return const TypeMatcher() .having((e) => e.message, 'message', msgMatcher); } test('when using star function parameters', () { final result = engine.analyze('SELECT bm25(*) FROM foo;'); expect(result.errors, [hasMessage(contains('star parameter'))]); }); test('when using a non-fts5 table as parameter', () { final result = engine.analyze('SELECT bm25(bar) FROM other'); expect(result.errors, [hasMessage(contains('fts5 table name'))]); }); test('when using the wrong number or arguments', () { final result = engine.analyze('SELECT highlight(foo, 3) FROM foo'); expect( result.errors, [ hasMessage(stringContainsInOrder(['highlight', '4', '2'])) ], ); }); test('with too many weights in bm25', () { final result = engine.analyze('SELECT bm25(foo, 0.5, 0.6, 0.1) FROM foo;'); expect( result.errors, [ hasMessage( 'Superfluous weight columns (there are only 2 columns on the table).') ], ); }); }); test('does not include rank and table columns in result', () { final engine = SqlEngine(_fts5Options); final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); final selectResult = engine.analyze('SELECT * FROM foo;'); final columns = (selectResult.root as SelectStatement).resolvedColumns; expect(columns, isNot(anyElement((Column c) => c.name == 'rank'))); expect(columns, isNot(anyElement((Column c) => c.name == 'foo'))); }); test('can select via table-valued function syntax', () { final engine = SqlEngine(_fts5Options)..registerTableFromSql(''' CREATE VIRTUAL TABLE email USING fts5 (sender, title, body); '''); final result = engine.analyze("SELECT * FROM email('fts5')"); expect(result.errors, isEmpty); final rootNode = result.root as SelectStatement; for (final column in rootNode.resolvedColumns!) { expect(column.source, isA()); } }); } test/engine/module/spellfix1_test.dart 644 0 0 3146 14345646642 16237 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; final _spellfixOptions = EngineOptions(enabledExtensions: const [Spellfix1Extension()]); void main() { final engine = SqlEngine(_spellfixOptions); test('creating spellfix1 table', () { final result = engine.analyze('CREATE VIRTUAL TABLE demo USING spellfix1;'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'demo'); final columns = table.resultColumns; expect(columns, hasLength(6)); }); group('engine analyze spellfix1', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_spellfixOptions); final fts5Result = engine.analyze('CREATE VIRTUAL TABLE demo USING spellfix1;'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); test('ignore hidden columns in result', () { final result = engine.analyze('SELECT * FROM demo WHERE word MATCH \'none\''); expect(result.errors, isEmpty); final select = result.root as SelectStatement; expect(select.resolvedColumns, hasLength(6)); }); test('accepts hidden columns in query', () { final result = engine .analyze('SELECT * FROM demo WHERE word MATCH \'none\' AND top=3'); expect(result.errors, isEmpty); }); test('consideres hidden columns', () { final result = engine.analyze( 'SELECT * FROM demo WHERE word MATCH \'none\' AND noneexistent=3'); expect(result.errors, hasLength(1)); }); }); } test/engine/module/rtree_test.dart 644 0 0 6435 14345646642 15455 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; final _rtreeOptions = EngineOptions(enabledExtensions: const [RTreeExtension()]); void main() { group('creating rtree tables', () { final engine = SqlEngine(_rtreeOptions); test('can create rtree table', () { final result = engine.analyze(''' CREATE VIRTUAL TABLE demo_index USING rtree( id, -- Integer primary key minX, maxX, -- Minimum and maximum X coordinate minY, maxY -- Minimum and maximum Y coordinate );'''); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'demo_index'); final columns = table.resultColumns; expect(columns, hasLength(5)); expect(columns.first.type.type, equals(BasicType.int)); expect(columns.last.type.type, equals(BasicType.real)); }); group('validate arguments', () { test('invalid coordinate count', () { final result = engine.analyze(''' CREATE VIRTUAL TABLE demo_index USING rtree( id, -- Integer primary key minX, maxX, -- Minimum and maximum X coordinate minY );'''); expect( () => const SchemaFromCreateTable() .read(result.root as TableInducingStatement), throwsArgumentError); }); test('no coordinates', () { final result = engine.analyze(''' CREATE VIRTUAL TABLE demo_index USING rtree( id -- Integer primary key );'''); expect( () => const SchemaFromCreateTable() .read(result.root as TableInducingStatement), throwsArgumentError); }); test('too many dimensions', () { final result = engine.analyze(''' CREATE VIRTUAL TABLE demo_index USING rtree( id, -- Integer primary key minX, maxX, -- Minimum and maximum X coordinate minY, maxY, minY, maxY, minY, maxY, minY, maxY, minY, maxY );'''); expect( () => const SchemaFromCreateTable() .read(result.root as TableInducingStatement), throwsArgumentError); }); }); }); group('type inference for function arguments', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_rtreeOptions); // add an fts5 table for the following queries final result = engine.analyze(''' CREATE VIRTUAL TABLE demo_index USING rtree( id, -- Integer primary key minX, maxX, -- Minimum and maximum X coordinate minY, maxY -- Minimum and maximum Y coordinate );'''); engine.registerTable(const SchemaFromCreateTable() .read(result.root as TableInducingStatement)); }); test('insert', () { final result = engine.analyze('INSERT INTO demo_index VALUES ' '(28215, -80.781227, -80.604706, 35.208813, 35.297367);'); expect(result.errors, isEmpty); }); test('select', () { final result = engine.analyze(''' SELECT A.* FROM demo_index AS A, demo_index AS B WHERE A.maxX>=B.minX AND A.minX<=B.maxX AND A.maxY>=B.minY AND A.minY<=B.maxY AND B.id=28269;'''); final columns = (result.root as SelectStatement).resolvedColumns; expect(result.errors, isEmpty); expect(columns, hasLength(5)); }); }); } test/engine/options.dart 644 0 0 654 14345646642 13460 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('refuses to work with old sqlite versions', () { expect(() => EngineOptions(version: const SqliteVersion.v3(12)), throwsArgumentError); }); test('refuses to work with unsupported new sqlite versions', () { expect(() => EngineOptions(version: const SqliteVersion.v3(99)), throwsArgumentError); }); } test/utils 755 0 0 0 0 10343 5ustar0 pubpubtest/utils/find_referenced_tables_test.dart 644 0 0 7256 14711507160 17364 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/utils/find_referenced_tables.dart'; import 'package:test/test.dart'; void main() { late SqlEngine engine; const schemaReader = SchemaFromCreateTable(); late Table users, logins; late View oldUsers; setUpAll(() { engine = SqlEngine(); Table addTableFromStmt(String create) { final parsed = engine.parse(create); final table = schemaReader.read(parsed.rootNode as CreateTableStatement); engine.registerTable(table); return table; } View addViewFromStmt(String create) { final result = engine.analyze(create); final view = schemaReader.readView(result, result.root as CreateViewStatement); engine.registerView(view); return view; } users = addTableFromStmt(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY, name TEXT NOT NULL, ); '''); logins = addTableFromStmt(''' CREATE TABLE logins ( user INTEGER NOT NULL REFERENCES users (id), timestamp INT ); '''); oldUsers = addViewFromStmt(''' CREATE VIEW old_users AS SELECT u.* FROM users u WHERE (SELECT MAX(timestamp) FROM logins WHERE user = u.id) < 10000; '''); }); test('recognizes read tables', () { final ctx = engine.analyze('SELECT * FROM logins INNER JOIN users u ' 'ON u.id = logins.user;'); expect(findReferencedTables(ctx.root), {users, logins}); }); test('finds views', () { final ctx = engine.analyze('SELECT * FROM old_users WHERE id > 10'); final visitor = ReferencedTablesVisitor()..visit(ctx.root, null); expect(visitor.foundViews, {oldUsers}); }); test('resolves aliased tables', () { final ctx = engine.analyze(''' CREATE TRIGGER foo AFTER INSERT ON users BEGIN INSERT INTO logins (user, timestamp) VALUES (new.id, 0); END; '''); expect(ctx.errors, isEmpty); final body = (ctx.root as CreateTriggerStatement).action; // Users referenced via "new" in body. expect(findReferencedTables(body), contains(users)); }); group('recognizes written tables', () { test('for insert', () { final ctx = engine.analyze('INSERT INTO logins ' 'SELECT id, CURRENT_TIME FROM users;'); expect( findWrittenTables(ctx.root), {TableWrite(logins, UpdateKind.insert)}); }); test('for deletes', () { final ctx = engine.analyze('DELETE FROM users;'); expect( findWrittenTables(ctx.root), {TableWrite(users, UpdateKind.delete)}); }); test('for views', () { final ctx = engine.analyze('UPDATE old_users SET name = ?'); expect(findWrittenTables(ctx.root), {TableWrite(oldUsers, UpdateKind.update)}); }); }); test('ignores unresolved references', () { final ctx = engine.analyze('UPDATE xzy SET foo = bar'); expect(findWrittenTables(ctx.root), isEmpty); expect(ctx.errors, hasLength(3)); // unknown table, two unknown references }); group('find references without analysis', () { void testWith(String sql, Set references) { final result = engine.parse(sql); expect(result.errors, isEmpty); final found = engine.findReferencedSchemaTables(result.rootNode); expect(found, references, reason: 'Query `$sql` references `$references`'); } test('finds references for simple queries', () { testWith('SELECT * FROM foo', {'foo'}); testWith('DELETE FROM bar', {'bar'}); testWith('VALUES (1, 2, 3)', {}); }); test('does not include references resolved in the query', () { testWith('WITH foo AS (VALUES(1,2,3)) SELECT * FROM foo', {}); }); }); } test/utils/ast_quality_test.dart 644 0 0 2764 14345646642 15302 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/expect.dart'; import 'package:test/scaffolding.dart'; void main() { group(enforceEqualIterable, () { test('should accept 2 equal iterables', () { enforceEqualIterable( [ NotNull('foo'), ], [ NotNull('foo'), ], ); }); test('should throw if only first is empty', () { expect( () => enforceEqualIterable( [], [ NotNull('foo'), ], ), throwsA(isA()), ); }); test('should throw if only second is empty', () { expect( () => enforceEqualIterable( [ NotNull('foo'), ], [], ), throwsA(isA()), ); }); test('should throw if first is shorter', () { expect( () => enforceEqualIterable( [ NotNull('foo'), ], [ NotNull('foo'), UniqueColumn('foo', null), ], ), throwsA(isA()), ); }); test('should throw if second is shorter', () { expect( () => enforceEqualIterable( [ NotNull('foo'), UniqueColumn('foo', null), ], [ NotNull('foo'), ], ), throwsA(isA()), ); }); }); } test/utils/node_to_text_test.dart 644 0 0 42036 14623415614 15442 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:sqlparser/utils/node_to_text.dart'; import 'package:test/test.dart'; enum _ParseKind { statement, driftFile, multipleStatements, } void main() { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())); void testFormat(String input, {_ParseKind kind = _ParseKind.statement, String? expectedOutput}) { AstNode parse(String input) { late ParseResult result; switch (kind) { case _ParseKind.statement: result = engine.parse(input); break; case _ParseKind.driftFile: result = engine.parseDriftFile(input); break; case _ParseKind.multipleStatements: result = engine.parseMultiple(input); break; } if (result.errors.isNotEmpty) { fail('Error parsing $input: ${result.errors.join('\n')}'); } return result.rootNode; } final originalAst = parse(input); final formatted = originalAst.toSql(); if (expectedOutput != null) { expect(formatted, expectedOutput); } else { // Just make sure we emit something equal to what we got final newAst = parse(formatted); try { enforceEqual(originalAst, newAst); } catch (e) { fail('Not equal after formatting: $input to $formatted: $e'); } } } group('create', () { group('trigger', () { test('before delete', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger BEFORE DELETE ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('instead of insert', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger INSTEAD OF INSERT ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('after update', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER UPDATE ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('after update of when', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER UPDATE OF c1, c2 ON t1 WHEN foo = bar BEGIN SELECT * FROM t2; END; '''); }); test('Using RAISE', () { testFormat(''' CREATE TRIGGER my_trigger AFTER DELETE ON t1 BEGIN SELECT RAISE(ABORT, 'please don''t'); END; '''); }); }); test('view', () { testFormat(''' CREATE VIEW my_view (foo, bar) AS SELECT * FROM t1; '''); testFormat(''' CREATE VIEW my_view AS SELECT * FROM t1; '''); testFormat(''' CREATE VIEW my_view AS Foo (foo, bar) AS SELECT * FROM t1; '''); testFormat(''' CREATE VIEW my_view WITH Foo.constr (foo, bar) AS SELECT * FROM t1; '''); }); group('table', () { test('complex', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo TEXT NOT NULL PRIMARY KEY DEFAULT (3 * 4), baz INT CONSTRAINT not_null NOT NULL PRIMARY KEY AUTOINCREMENT, bar TEXT UNIQUE ON CONFLICT IGNORE CHECK (3 * 4 = 12) DEFAULT 'some string here' COLLATE c REFERENCES t2 (c) ON DELETE RESTRICT ON UPDATE NO ACTION, PRIMARY KEY (foo, bar DESC) ON CONFLICT ABORT, UNIQUE (baz) ON CONFLICT REPLACE, CONSTRAINT my_constraint CHECK(baz < 3), FOREIGN KEY (foo, baz) REFERENCES t2 ON DELETE SET NULL ON UPDATE CASCADE DEFERRABLE INITIALLY IMMEDIATE, FOREIGN KEY (bar) REFERENCES t2 (bax) ON DELETE SET DEFAULT NOT DEFERRABLE ); '''); }); test('WITHOUT ROWID', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) WITHOUT ROWID; '''); }); test('STRICT', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) STRICT; '''); }); test('STRICT and WITHOUT ROWID', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) WITHOUT ROWID, STRICT; '''); }); test('with existing row class', () { testFormat(''' CREATE TABLE foo (bar INTEGER NOT NULL PRIMARY KEY) With FooData.myConstructor; '''); }); test('virtual', () { testFormat('CREATE VIRTUAL TABLE foo USING bar(a, b, c);'); }); test('not null', () { testFormat('CREATE TABLE foo (bar TEXT NOT NULL);'); }); test('null constraint', () { testFormat('CREATE TABLE foo (bar TEXT NULL);'); }); }); test('index', () { testFormat(''' CREATE INDEX my_idx ON t1 (c1, c2, c3); '''); testFormat(''' CREATE UNIQUE INDEX my_idx ON t1 (c1, c2, c3) WHERE c1 < c3; '''); }); }); group('escapes identifiers', () { test("when they're keywords", () { testFormat('SELECT * FROM "create";'); }); test('when they contain whitespace', () { testFormat('SELECT * FROM "my fancy table"'); }); }); group('misc', () { test('transactions', () { testFormat('BEGIN DEFERRED TRANSACTION;'); testFormat('BEGIN IMMEDIATE'); testFormat('BEGIN EXCLUSIVE'); testFormat('COMMIT'); testFormat('END TRANSACTION'); }); }); group('query statements', () { group('select', () { test('with common table expressions', () { testFormat(''' WITH RECURSIVE foo (id) AS (VALUES(1) UNION ALL SELECT id + 1 FROM foo) SELECT * FROM foo; '''); }); test('escapes CTEs', () { testFormat('WITH alias("first", second) AS (SELECT * FROM foo) ' 'SELECT * FROM alias'); }); test('with materialized CTEs', () { testFormat(''' WITH foo (id) AS NOT MATERIALIZED (SELECT 1), bar (id) AS MATERIALIZED (SELECT 2) SELECT * FROM foo UNION ALL SELECT * FROM bar; '''); }); test('compound', () { testFormat(''' SELECT * FROM foo UNION ALL SELECT * FROM bar UNION SELECT * FROM baz INTERSECT SELECT * FROM bar2 EXCEPT SELECT * FROM bar3 LIMIT 5; '''); }); test('values', () { testFormat('VALUES (1,2,3), (4,5,6);'); }); test('group by', () { testFormat(''' SELECT * FROM foo GROUP BY a, b, c HAVING COUNT(id) > 10 '''); }); test('with LIST column', () { testFormat('SELECT LIST(SELECT * FROM foo) AS r'); }); test('with expression', () { testFormat('SELECT 1, 2 AS r, 3'); }); test('with mapped by column', () { testFormat('SELECT 1 MAPPED BY `MyEnumConverter()`'); }); test('with windows', () { testFormat(''' SELECT * FROM foo WINDOW my_window AS ( PARTITION BY bar GROUPS BETWEEN 3 PRECEDING AND CURRENT ROW EXCLUDE NO OTHERS ), other AS (my_window ORDER BY foo DESC, bar ASC NULLS FIRST RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW ), yet_another AS (other RANGE CURRENT ROW EXCLUDE GROUP), finally AS (other RANGE BETWEEN CURRENT ROW AND 4 FOLLOWING EXCLUDE TIES ) '''); }); test('window function expressions', () { // https://github.com/simolus3/drift/issues/2273 testFormat(''' SELECT ROW_NUMBER() OVER ( ORDER BY date ) AS rn, date( date, '-' || ROW_NUMBER() OVER ( ORDER BY date ) || ' day' ) AS grp, date FROM dates '''); }); test('aggregate', () { testFormat(''' SELECT subs_id, subs_name, COUNT(is_skipped) FILTER (WHERE is_skipped = true) skipped, COUNT(is_touched) FILTER (WHERE is_touched = true) touched, COUNT(is_passed) FILTER (WHERE is_passed = true) passed FROM stats GROUP BY subs_id; '''); }); test('aggregate with order by', () { testFormat(''' SELECT string_agg(foo, ',' ORDER BY foo DESC, bar), string_agg(foo, ',' ORDER BY foo DESC) FILTER (WHERE foo > 10) FROM bar '''); }); group('joins', () { for (final kind in ['LEFT', 'RIGHT', 'FULL']) { test(kind, () { testFormat('SELECT * FROM foo $kind JOIN bar;'); testFormat('SELECT * FROM foo $kind OUTER JOIN bar;'); testFormat('SELECT * FROM foo NATURAL $kind JOIN bar;'); testFormat('SELECT * FROM foo NATURAL $kind OUTER JOIN bar;'); }); } test('complex', () { testFormat(''' SELECT * FROM foo AS f, bar NATURAL INNER JOIN j1 USING (foo) LEFT JOIN j2 ON j2.id = bar.c LEFT OUTER JOIN j3 ON j3.id = bar.c CROSS JOIN j4 ON j4.a = j3.b INNER JOIN (SELECT * FROM bar) AS b INNER JOIN table_valued_function(foo) '''); }); }); test('table references', () { testFormat('SELECT * FROM foo'); testFormat('SELECT * FROM main.foo'); }); test('limit', () { testFormat('SELECT * FROM foo LIMIT 3, 4'); testFormat('SELECT * FROM foo LIMIT 4 OFFSET 3'); }); test('order by', () { testFormat('SELECT foo.* FROM foo ORDER BY foo NULLS FIRST'); }); }); group('delete', () { test('with CTEs', () { testFormat( 'WITH foo (id) AS (SELECT * FROM bar) DELETE FROM bar WHERE x;'); }); test('with returning', () { testFormat('DELETE FROM foo RETURNING *'); }); }); group('insert', () { test('replace', () { testFormat('WITH foo (id) AS (SELECT * FROM bar) ' 'REPLACE INTO foo DEFAULT VALUES'); }); test('into select', () { testFormat('INSERT INTO foo SELECT * FROM bar'); }); test('with returning', () { testFormat('INSERT INTO foo DEFAULT VALUES RETURNING *'); }); test('with returning and insert mode', () { testFormat('INSERT OR IGNORE INTO foo DEFAULT VALUES RETURNING *'); }); test('upsert - do nothing', () { testFormat( 'INSERT OR REPLACE INTO foo DEFAULT VALUES ON CONFLICT DO NOTHING'); }); test('upsert with conflict target', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ON CONFLICT (a, b, c) ' 'DO NOTHING;'); }); test('upsert with conflict target and where', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT (a, b, c) WHERE foo = bar DO NOTHING;'); }); test('upsert - update', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT DO UPDATE SET a = b, c = d WHERE d < a;'); }); test('upsert - update with column-name-list', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT DO UPDATE SET (a, c) = (b, d) WHERE d < a;'); }); test('upsert - multiple clauses', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT DO NOTHING ' 'ON CONFLICT DO UPDATE SET a = b, c = d WHERE d < a;'); }); }); group('update', () { test('simple', () { testFormat('UPDATE foo SET bar = baz WHERE 1;'); }); test('with column-name-list', () { testFormat('UPDATE foo SET (bar, baz) = (baz, bar) WHERE 1;'); }); test('with column-name-list and subquery', () { testFormat('UPDATE foo SET (bar, baz) = (SELECT 1,2) WHERE 1;'); }); test('with returning', () { testFormat('UPDATE foo SET bar = baz RETURNING *'); }); const modes = [ 'OR ABORT', 'OR FAIL', 'OR IGNORE', 'OR REPLACE', ' OR ROLLBACK', ]; for (var i = 0; i < modes.length; i++) { test('failure mode #$i', () { testFormat('UPDATE ${modes[i]} foo SET bar = baz'); }); } test('from', () { testFormat('UPDATE foo SET bar = baz FROM t1 CROSS JOIN t2'); }); }); }); group('expressions', () { test('between', () { testFormat('SELECT x BETWEEN a AND b'); testFormat('SELECT x NOT BETWEEN a AND b'); }); test('binary', () { testFormat('SELECT x OR y'); testFormat('SELECT x AND y'); }); test('in', () { testFormat('SELECT x IN (SELECT * FROM foo);'); testFormat('SELECT x NOT IN (SELECT * FROM foo);'); testFormat('SELECT x IN foo'); testFormat('SELECT x IN json_each(bar)'); testFormat('SELECT x IN :array'); }); test('boolean literals', () { testFormat('SELECT TRUE OR FALSE'); }); test('case', () { testFormat('SELECT CASE WHEN a THEN b ELSE C END'); testFormat('SELECT CASE x WHEN a THEN b WHEN c THEN d END'); }); test('cast', () { testFormat('SELECT CAST(X AS INTEGER)'); }); test('collate', () { testFormat('SELECT x COLLATE y AS xc'); }); test('exists', () { testFormat('SELECT x FROM foo WHERE EXISTS (SELECT * FROM bar)'); }); test('function', () { testFormat('SELECT my_function(*) FROM foo'); testFormat('SELECT my_function(DISTINCT a, b) FROM foo'); testFormat('SELECT my_function(a, b) FROM foo'); }); test('is', () { testFormat('SELECT foo IS bar'); testFormat('SELECT foo IS NOT bar'); }); test('is DISTINCT FROM', () { testFormat('SELECT foo IS DISTINCT FROM bar', expectedOutput: 'SELECT foo IS NOT bar'); testFormat('SELECT foo IS NOT DISTINCT FROM bar', expectedOutput: 'SELECT foo IS bar'); }); test('is null', () { testFormat('SELECT foo ISNULL'); testFormat('SELECT foo NOTNULL'); }); test('null literal', () { testFormat('SELECT NULL;'); }); test('parentheses', () { testFormat('SELECT (3 + 4) * 5'); }); test('reference with table', () { testFormat('SELECT foo.bar FROM foo'); }); test('string comparison', () { testFormat('SELECT x LIKE y FROM foo'); }); test('time literals', () { testFormat('SELECT CURRENT_TIME;'); testFormat('SELECT CURRENT_DATE;'); testFormat('SELECT CURRENT_TIMESTAMP;'); }); test('unary expression', () { testFormat('SELECT -(+(~3));'); }); test('references', () { testFormat('SELECT foo'); testFormat('SELECT foo.bar'); testFormat('SELECT foo.bar.baz'); }); test('json', () { testFormat('SELECT a -> b'); testFormat('SELECT a ->> b'); }); test('blob literal', () { testFormat( "select typeof(X'0100000300000000000000000000803F000000000000003F0000803F');"); }); }); test('identifiers', () { void testWith(String id, String formatted) { final node = Reference(columnName: id); expect(node.toSql(), formatted); } testWith('a', 'a'); testWith('_', '_'); testWith('c0', 'c0'); testWith('_c0', '_c0'); testWith('a b', '"a b"'); testWith(r'a$b', r'"a$b"'); }); group('drift', () { group('dart placeholders', () { test('expression', () { testFormat(r'SELECT $placeholder FROM foo'); }); test('limit', () { testFormat(r'SELECT * FROM foo LIMIT $limit'); }); test('ordering term', () { testFormat(r'SELECT * FROM foo ORDER BY $term DESC'); }); test('order by clause', () { testFormat(r'SELECT * FROM foo ORDER BY $clause'); }); test('insertable', () { testFormat(r'INSERT INTO foo $companion'); }); }); test('imports', () { testFormat('import \'foo.bar\';', kind: _ParseKind.driftFile); }); test('declared statements', () { testFormat('foo (?1 AS INT): SELECT * FROM bar WHERE ? < 10;', kind: _ParseKind.driftFile); testFormat('foo: SELECT * FROM bar WHERE :id < 10;', kind: _ParseKind.driftFile); testFormat('foo (REQUIRED :x AS TEXT OR NULL): SELECT :x;', kind: _ParseKind.driftFile); testFormat(r'foo ($pred = FALSE): SELECT * FROM bar WHERE $pred;', kind: _ParseKind.driftFile); }); test('nested star', () { testFormat('q: SELECT foo.** FROM foo;', kind: _ParseKind.driftFile); }); test('transaction block', () { testFormat( ''' test: BEGIN TRANSACTION SELECT * FROM foo; UPDATE foo SET bar = baz; DELETE FROM x; INSERT INTO foo VALUES (x, y, z); COMMIT TRANSACTION; ''', kind: _ParseKind.driftFile, ); }); }); test('does not format invalid statements', () { expect(InvalidStatement().toSql, throwsUnsupportedError); }); test('multiple statements', () { testFormat(''' CREATE TABLE my_table ( id INTEGER NOT NULL PRIMARY KEY, another TEXT ) STRICT; BEGIN; INSERT INTO foo (bar, baz) VALUES ('hi', 3); COMMIT; ''', kind: _ParseKind.multipleStatements); }); } test/analysis 755 0 0 0 0 11026 5ustar0 pubpubtest/analysis/errors 755 0 0 0 0 12342 5ustar0 pubpubtest/analysis/errors/utils.dart 644 0 0 1423 14623415614 15022 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; extension ExpectErrors on AnalysisContext { void expectError(String lexeme, {AnalysisErrorType? type, message}) { expect( errors, [analysisErrorWith(lexeme: lexeme, type: type, message: message)], ); } void expectNoError() { expect(errors, isEmpty); } } Matcher analysisErrorWith({String? lexeme, AnalysisErrorType? type, message}) { var matcher = isA(); if (lexeme != null) { matcher = matcher.having((e) => e.span?.text, 'span.text', lexeme); } if (type != null) { matcher = matcher.having((e) => e.type, 'type', type); } if (message != null) { matcher = matcher.having((e) => e.message, 'message', message); } return matcher; } test/analysis/errors/invalid_trigger_mode_test.dart 644 0 0 2247 14711507160 21077 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { final engine = SqlEngine() ..registerTable(demoTable) ..registerViewFromSql('CREATE VIEW my_view AS SELECT 1 as c;'); test('does not allow INSTEAD OF on tables', () { final result = engine.analyze(''' CREATE TRIGGER my_trigger INSTEAD OF INSERT ON demo BEGIN SELECT 1; END; '''); result.expectError( 'demo', type: AnalysisErrorType.invalidTriggerMode, message: contains('only allowed on views'), ); engine.analyze(''' CREATE TRIGGER my_trigger INSTEAD OF INSERT ON my_view BEGIN SELECT 1; END; ''').expectNoError(); }); test('does not allow AFTER on views', () { final result = engine.analyze(''' CREATE TRIGGER my_trigger AFTER INSERT ON my_view BEGIN SELECT 1; END; '''); result.expectError( 'my_view', type: AnalysisErrorType.invalidTriggerMode, message: contains('Only `INSTEAD OF` triggers are allowed for views'), ); }); } test/analysis/errors/all_columns_are_generated_test.dart 644 0 0 1407 14345646642 22110 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error if all columns are generated', () { final result = SqlEngine().analyze(''' CREATE TABLE a ( a TEXT GENERATED ALWAYS AS ('a'), b TEXT GENERATED ALWAYS AS ('b') ); '''); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.allColumnsAreGenerated); }); test('does not report an error if a non-generated column exists', () { final result = SqlEngine().analyze(''' CREATE TABLE a ( a TEXT GENERATED ALWAYS AS ('a'), b TEXT GENERATED ALWAYS AS ('b'), c TEXT ); '''); expect(result.errors, isEmpty); }); } test/analysis/errors/values_select_count_mismatch_test.dart 644 0 0 1170 14345646642 22663 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error when using different-length tuples in VALUES', () { final stmt = SqlEngine().analyze('VALUES (1, 2), (3)'); expect( stmt.errors, contains( isA() .having((e) => e.type, 'type', AnalysisErrorType.valuesSelectCountMismatch) .having((e) => e.message, 'message', allOf(contains('1'), contains('2'))) .having( (e) => e.source!.span!.text, 'relevantNode.span.text', '(3)'), ), ); }); } test/analysis/errors/compound_column_mismatch_test.dart 644 0 0 735 14345646642 22004 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('reports column count mismatch in compound select query', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo UNION SELECT 1'); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.compoundColumnCountMismatch); }); } test/analysis/errors/row_value_misuse_test.dart 644 0 0 5576 14623415614 20326 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { late SqlEngine engine; setUp(() { // enable json1 extension engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_38)); }); test('when using row value in select', () { engine .analyze('SELECT (1, 2, 3)') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in BETWEEN expression', () { engine .analyze('SELECT 1 BETWEEN (1, 2, 3) AND 3') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - value', () { engine .analyze('SELECT CASE 1 WHEN 1 THEN (1, 2, 3) ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - when', () { engine .analyze('SELECT CASE 1 WHEN (1, 2, 3) THEN 1 ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - base', () { engine .analyze('SELECT CASE (1, 2, 3) WHEN 1 THEN 1 ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); group('does not generate error for valid usage', () { test('in comparison', () { engine.analyze('SELECT (1, 2, 3) < (?, ?, ?);').expectNoError(); }); test('in IN expression (lhs)', () { engine.analyze('SELECT (1, 2, 3) IN (VALUES(0, 1, 2))').expectNoError(); }); test('in IN expression (rhs)', () { engine.analyze('SELECT ? IN (1, 2, 3)').expectNoError(); }); test('in BETWEEN expression', () { engine.analyze('SELECT (1, 2) BETWEEN (3, 4) AND (5, 6)').expectNoError(); }); test('in CASE expression', () { engine .analyze('SELECT CASE (1, 2) WHEN (1, 2) THEN 1 ELSE 0 END') .expectNoError(); }); }); group('in expressions', () { test('when tuple is expected', () { engine.analyze('SELECT (1, 2) IN ((4, 5), 6)').expectError('6', type: AnalysisErrorType.other, message: contains('Expected 2 columns in this entry, got 1')); }); test('when tuple is not expected', () { engine.analyze('SELECT 1 IN ((4, 5), 6)').expectError('(4, 5)', type: AnalysisErrorType.other, message: contains('Expected 1 columns in this entry, got 2')); }); test('for table reference', () { engine .analyze('WITH names AS (VALUES(1, 2, 3)) SELECT (1, 2) IN names') .expectError('names', type: AnalysisErrorType.other, message: contains('must have 2 columns (it has 3)')); }); test('for table-valued function', () { engine.analyze("SELECT (1, 2) IN json_each('{}')").expectError( "json_each('{}')", type: AnalysisErrorType.other, message: contains('this table must have 2 columns (it has 8)')); }); }); } test/analysis/errors/misc_test.dart 644 0 0 712 14345646642 15644 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { final engine = SqlEngine()..registerTable(demoTable); test('warns about multiple parameters with DISTINCT', () { engine .analyze("SELECT group_concat(DISTINCT content, '-') FROM demo") .expectError('DISTINCT', type: AnalysisErrorType.distinctAggregateWithWrongParameterCount); }); } test/analysis/errors/raise_outside_of_triggers_test.dart 644 0 0 1563 14345646642 22167 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('does not report errors for RAISE used in triggers', () { final engine = SqlEngine(); engine.registerTable(demoTable); final result = engine.analyze(''' CREATE TRIGGER my_trigger AFTER INSERT ON demo BEGIN SELECT RAISE(FAIL, 'Not allowed'); END; '''); expect(result.errors, isEmpty); }); test('does not allow RAISE in top-level statements', () { final engine = SqlEngine(); final result = engine.analyze("SELECT RAISE(FAIL, 'Not allowed');"); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.type, 'type', AnalysisErrorType.raiseMisuse), ); }); } test/analysis/errors/duplicate_primary_key_test.dart 644 0 0 2733 14345646642 21323 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { void check(String sql, List problems) { final engine = SqlEngine(); final parseResult = engine.parse(sql); engine.registerTable(const SchemaFromCreateTable() .read(parseResult.rootNode as CreateTableStatement)); final context = engine.analyzeParsed(parseResult); expect( context.errors, pairwiseCompare( problems, (span, err) => err.span?.text == span, 'with span', ), ); } test('not reported on a correct table', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT ); ''', [], ); }); test('multiple column constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT PRIMARY KEY, ); ''', ['PRIMARY KEY'], ); }); test('with column and table constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT, PRIMARY KEY (foo, bar) ); ''', ['PRIMARY KEY (foo, bar)'], ); }); test('multiple table constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER, bar TEXT, PRIMARY KEY (foo), PRIMARY KEY (bar) ); ''', ['PRIMARY KEY (bar)'], ); }); } test/analysis/errors/limit_or_order_by_in_compound_test.dart 644 0 0 2231 14345646642 23024 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error if LIMIT is used before last part', () { final engine = SqlEngine(); final analyzed = engine.analyze('SELECT 1 LIMIT 3 UNION SELECT 2'); expect(analyzed.errors, hasLength(1)); final error = analyzed.errors.single; expect(error.type, AnalysisErrorType.synctactic); final problematicSelect = (analyzed.root as CompoundSelectStatement).base; final wrongLimit = (problematicSelect as SelectStatement).limit; expect(error.source, wrongLimit); }); test('reports error if ORDER BY is used before last part', () { final engine = SqlEngine(); final analyzed = engine.analyze(''' SELECT 1 UNION SELECT 1 ORDER BY 2 INTERSECT SELECT 1 '''); expect(analyzed.errors, hasLength(1)); final error = analyzed.errors.single; expect(error.type, AnalysisErrorType.synctactic); final problematicSelect = (analyzed.root as CompoundSelectStatement).additional[0].select; final wrongOrderBy = (problematicSelect as SelectStatement).orderBy; expect(error.source, wrongOrderBy); }); } test/analysis/errors/create_table_errors_test.dart 644 0 0 5107 14370670576 20743 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { final oldEngine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)); final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); final engineInDriftMode = SqlEngine(EngineOptions( version: SqliteVersion.v3_37, driftOptions: const DriftSqlOptions())); group('using STRICT', () { test('with an old sqlite3 version', () { const stmt = 'CREATE TABLE a (c INTEGER) STRICT'; oldEngine.analyze(stmt).expectError('STRICT', type: AnalysisErrorType.notSupportedInDesiredVersion); engine.analyze(stmt).expectNoError(); }); test( 'without a column type', () { engine .analyze('CREATE TABLE a (c) STRICT;') .expectError('c', type: AnalysisErrorType.noTypeNameInStrictTable); }, ); test( 'with an invalid column type', () { engine.analyze('CREATE TABLE a (c INTEGER(12)) STRICT;').expectError( 'INTEGER(12)', type: AnalysisErrorType.invalidTypeNameInStrictTable, ); }, ); test('with a type that is only valid in drift mode', () { // https://github.com/simolus3/drift/discussions/1651 engineInDriftMode .analyze('CREATE TABLE a (c IS_DATETIME, b DECIMAL, c REAL) STRICT;') .expectNoError(); }); }); test('using WITHOUT ROWID and then not declaring a primary key', () { engine .analyze('CREATE TABLE a (c INTEGER) WITHOUT ROWID') .expectError('a', type: AnalysisErrorType.missingPrimaryKey); engine.analyze('CREATE TABLE a (c INTEGER);').expectNoError(); engine .analyze('CREATE TABLE a (c INTEGER PRIMARY KEY) WITHOUT ROWID;') .expectNoError(); final errors = engine.analyze('CREATE TABLE a (c INTEGER, PRIMARY KEY (c));'); expect( errors, isNot(contains( analysisErrorWith(type: AnalysisErrorType.missingPrimaryKey)))); }); test('multiple primary key constraints', () { engine .analyze( 'CREATE TABLE a (c INTEGER PRIMARY KEY, c2 INTEGER PRIMARY KEY)') .expectError('PRIMARY KEY', type: AnalysisErrorType.duplicatePrimaryKeyDeclaration); final errors = engine .analyze('CREATE TABLE a (c INTEGER PRIMARY KEY, c2, PRIMARY KEY (c2))') .errors; expect( errors, contains(analysisErrorWith( lexeme: 'PRIMARY KEY (c2)', type: AnalysisErrorType.duplicatePrimaryKeyDeclaration)), ); }); } test/analysis/errors/view_column_names_mismatch_test.dart 644 0 0 765 14345646642 22320 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('reports column name mismatches in CREATE VIEW statements', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('CREATE VIEW my_view (foo) AS ' 'SELECT * FROM demo;'); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.viewColumnNamesMismatch); }); } test/analysis/errors/syntax_error_test.dart 644 0 0 11175 14612235271 17502 0ustar0 pubpub// tests for syntax errors revealed during static analysis. import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { group('DO UPDATE clause without conflict target', () { test('is forbidden on older sqlite versions', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3;'); expect(result.errors, [ const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.synctactic) .having((e) => e.message, 'message', contains('Expected a conflict clause')) ]); }); test('is allowed on the last clause', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTable(demoTable); expect( engine .analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3;') .errors, isEmpty, ); }); test('is not allowed on previous clauses', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTable(demoTable); expect( engine .analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3' 'ON CONFLICT DO NOTHING;') .errors, hasLength(1), ); }); }); test('complex expressions in PRIMARY KEY clause', () { final engine = SqlEngine(); final parseResult = engine.parse(''' CREATE TABLE tbl ( foo INTEGER NOT NULL, bar TEXT NOT NULL, PRIMARY KEY (foo DESC, bar || 'test') ); '''); engine.registerTable(const SchemaFromCreateTable() .read(parseResult.rootNode as CreateTableStatement)); final analyzeResult = engine.analyzeParsed(parseResult); expect(analyzeResult.errors, [ const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.synctactic) .having((e) => e.message, 'message', contains('Only column names can be used in a PRIMARY KEY clause')) ]); }); group('illegal constructs in triggers', () { final engine = SqlEngine()..registerTable(demoTable); test('DEFAULT VALUES', () { engine.analyze('INSERT INTO demo DEFAULT VALUES').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'INSERT INTO demo DEFAULT VALUES;' 'END;') .expectError('DEFAULT VALUES', type: AnalysisErrorType.synctactic); }); test('WITH clauses', () { // https://sqlite.org/lang_with.html#limitations_and_caveats engine.analyze('WITH x AS (SELECT 1) SELECT 2').expectNoError(); engine.analyze(''' CREATE TRIGGER tgr AFTER INSERT ON demo BEGIN WITH x AS (SELECT 1) SELECT 2; END; ''').expectError('WITH', type: AnalysisErrorType.synctactic); }); group('aliased source tables', () { test('insert', () { engine.analyze('INSERT INTO demo AS d VALUES (?, ?)').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'INSERT INTO demo AS d VALUES (?, ?);' 'END;') .expectError('demo AS d', type: AnalysisErrorType.synctactic); }); test('update', () { engine.analyze('UPDATE demo AS d SET id = id + 1;').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'UPDATE demo AS d SET id = id + 1;' 'END;') .expectError('demo AS d', type: AnalysisErrorType.synctactic); }); test('delete', () { engine.analyze('DELETE FROM demo d;').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'DELETE FROM demo d;' 'END;') .expectError('demo d', type: AnalysisErrorType.synctactic); }); test('allowed in subquery', () { engine.analyze(''' CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN INSERT INTO demo (content) SELECT content FROM demo AS ok; END; ''').expectNoError(); }); }); }); test('window function with order by', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_44)) ..registerTable(demoTable); engine .analyze('SELECT group_concat(content ORDER BY id DESC) ' 'OVER (ROWS UNBOUNDED PRECEDING) FROM demo;') .expectError('ORDER BY id DESC'); }); } test/analysis/errors/invalid_parameter_count_test.dart 644 0 0 1260 14612235271 21613 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('is forbidden on older sqlite versions', () { final engine = SqlEngine(); final result = engine.analyze('SELECT iif (0, 1)'); expect(result.errors, [ analysisErrorWith( lexeme: '0, 1', type: AnalysisErrorType.invalidAmountOfParameters, message: 'iif expects 3 arguments, got 2.'), ]); }); test('sum', () { final engine = SqlEngine(); final result = engine.analyze('SELECT sum(1, 2, 3)'); result.expectError( '1, 2, 3', type: AnalysisErrorType.invalidAmountOfParameters, ); }); } test/analysis/errors/returning_test.dart 644 0 0 4072 14345646642 16751 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { final engine = SqlEngine(EngineOptions( enabledExtensions: const [Fts5Extension()], version: SqliteVersion.v3_35, )) ..registerTableFromSql('CREATE TABLE t (id INTEGER PRIMARY KEY, c2 TEXT);') ..registerTableFromSql( 'CREATE VIRTUAL TABLE vt USING fts5 (foo, bar, baz);'); test('does not allow RETURNING for statements in triggers', () { final result = engine.analyze(''' CREATE TRIGGER my_trigger AFTER INSERT ON t BEGIN INSERT INTO t VALUES (1, '') RETURNING *; END; '''); expect(result.errors, hasLength(1)); expect(result.errors.single.type, AnalysisErrorType.illegalUseOfReturning); }); test('does not allow RETURNING on virtual tables', () { final result = engine.analyze("INSERT INTO vt VALUES ('', '', '') RETURNING *;"); expect(result.errors, hasLength(1)); expect(result.errors.single.type, AnalysisErrorType.illegalUseOfReturning); }); test('does not allow star columns with an associated table', () { final result = engine.analyze(''' UPDATE t SET id = t.id + 1 FROM (SELECT * FROM t) AS old RETURNING old.*; '''); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.source!.span!.text, 'source.span.text', 'old.*') .having((e) => e.message, 'message', contains('RETURNING may not use the TABLE.* syntax')), ); }); test('does not allow aggregate expressions', () { final result = engine.analyze('INSERT INTO t DEFAULT VALUES RETURNING ' 'MAX(id) OVER (PARTITION BY c2)'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.source!.span!.text, 'source.span.text', 'MAX(id) OVER (PARTITION BY c2)') .having((e) => e.message, 'message', 'Aggregate expressions are not allowed in RETURNING'), ); }); } test/analysis/errors/write_to_generated_column.dart 644 0 0 1773 14612235271 21116 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(); engine.registerTableFromSql(''' CREATE TABLE a ( ok TEXT NOT NULL, g TEXT GENERATED ALWAYS AS (ok) STORED ); '''); }); test('reports error when updating generated column', () { engine .analyze("UPDATE a SET ok = 'new', g = 'old';") .expectError('g', type: AnalysisErrorType.writeToGeneratedColumn); }); test('reports error when updating generated column with column-name-list', () { engine .analyze("UPDATE a SET (ok, g) = ('new', 'old');") .expectError('g', type: AnalysisErrorType.writeToGeneratedColumn); }); test('reports error when inserting generated column', () { engine .analyze('INSERT INTO a (ok, g) VALUES (?, ?)') .expectError('g', type: AnalysisErrorType.writeToGeneratedColumn); }); } test/analysis/errors/update_column_name_list_count_mismatch_test.dart 644 0 0 4657 14612235271 24721 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(); engine.registerTableFromSql(''' CREATE TABLE foo ( a INTEGER NOT NULL, b INTEGER NOT NULL ); '''); }); group("using column-name-list and tuple in update", () { test('reports error if they have different sizes', () { engine .analyze("UPDATE foo SET (a, b) = (1);") .expectError('(1)', type: AnalysisErrorType.cteColumnCountMismatch); engine .analyze("UPDATE foo SET (a) = (1,2);") .expectError('(1,2)', type: AnalysisErrorType.cteColumnCountMismatch); }); test('reports no error if they have same sizes', () { engine.analyze("UPDATE foo SET (a, b) = (1,2);").expectNoError(); }); }); group("using column-name-list and values in update", () { test('reports error if they have different sizes', () { engine.analyze("UPDATE foo SET (a, b) = (VALUES(1));").expectError( "(VALUES(1))", type: AnalysisErrorType.cteColumnCountMismatch); engine.analyze("UPDATE foo SET (a) = (VALUES(1,2));").expectError( "(VALUES(1,2))", type: AnalysisErrorType.cteColumnCountMismatch); }); test('reports no error if they have same sizes', () { engine.analyze("UPDATE foo SET (a, b) = (VALUES(1,2));").expectNoError(); }); }); group("using column-name-list and subquery in update", () { test('reports error if they have different sizes', () { engine.analyze("UPDATE foo SET (a, b) = (SELECT 1);").expectError( '(SELECT 1)', type: AnalysisErrorType.cteColumnCountMismatch); engine.analyze("UPDATE foo SET (a) = (SELECT 1,2);").expectError( '(SELECT 1,2)', type: AnalysisErrorType.cteColumnCountMismatch); engine .analyze( "UPDATE foo SET (a, b) = (SELECT b FROM foo as f WHERE f.a=a);") .expectError('(SELECT b FROM foo as f WHERE f.a=a)', type: AnalysisErrorType.cteColumnCountMismatch); }); test('reports no error if they have same sizes', () { engine.analyze("UPDATE foo SET (a, b) = (SELECT 1,2);").expectNoError(); engine .analyze( "UPDATE foo SET (a, b) = (SELECT b, a FROM foo as f WHERE f.a=a);") .expectNoError(); }); }); } test/analysis/errors/unsupported_test.dart 644 0 0 13106 14612235271 17327 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { final minimumEngine = SqlEngine()..registerTable(demoTable); final currentEngine = SqlEngine(EngineOptions(version: SqliteVersion.current)) ..registerTable(demoTable); test('reports error for MATERIALIZED in CTEs', () { const sql = ''' WITH foo (x) AS MATERIALIZED (SELECT 1) SELECT 2; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having((e) => e.message, 'message', contains('requires sqlite3 version 35')) .having((e) => e.span!.text, 'span.text', 'MATERIALIZED'), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for multiple ON CONFLICT clauses', () { const sql = ''' INSERT INTO demo VALUES (3, 'hi') ON CONFLICT (content) DO NOTHING ON CONFLICT (id) DO UPDATE SET content = 'reset'; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA().having((e) => e.message, 'message', contains('require sqlite version 3.35 or later')), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for RETURNING on unsupported errors', () { const sql = ''' UPDATE demo SET content = content || content RETURNING *; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA().having((e) => e.message, 'message', 'RETURNING requires sqlite version 3.35 or later'), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for STRICT on an old sqlite3 version', () { const sql = 'CREATE TABLE a (b TEXT) STRICT'; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); context.expectError('STRICT', type: AnalysisErrorType.notSupportedInDesiredVersion); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('does not support `->` and `->>`in old sqlite3 versions', () { minimumEngine.analyze("SELECT '' -> ''").expectError('->', type: AnalysisErrorType.notSupportedInDesiredVersion); minimumEngine.analyze("SELECT '' ->> ''").expectError('->>', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze("SELECT '' -> ''").expectNoError(); currentEngine.analyze("SELECT '' ->> ''").expectNoError(); }); test('warns about using `printf` after 3.38', () { const sql = "SELECT printf('', 0, 'foo')"; currentEngine .analyze(sql) .expectError("printf('', 0, 'foo')", type: AnalysisErrorType.hint); minimumEngine.analyze(sql).expectNoError(); }); test('warns about using unixepoch before 3.38', () { const sql = "SELECT unixepoch('')"; minimumEngine.analyze(sql).expectError('unixepoch', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about using format before 3.38', () { const sql = "SELECT format('', 0, 'foo')"; minimumEngine.analyze(sql).expectError('format', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about unhex before 3.41', () { const sql = "SELECT unhex('abcd')"; minimumEngine.analyze(sql).expectError('unhex', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about timediff before 3.43', () { const sql = "SELECT timediff(?, ?)"; minimumEngine.analyze(sql).expectError('timediff', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about octet_length before 3.43', () { const sql = "SELECT octet_length('abcd')"; minimumEngine.analyze(sql).expectError('octet_length', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about `IS DISTINCT FROM`', () { const sql = 'SELECT id IS DISTINCT FROM content FROM demo;'; const notSql = 'SELECT id IS NOT DISTINCT FROM content FROM demo;'; minimumEngine.analyze(sql).expectError('DISTINCT FROM', type: AnalysisErrorType.notSupportedInDesiredVersion); minimumEngine.analyze(notSql).expectError('DISTINCT FROM', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); currentEngine.analyze(notSql).expectNoError(); }); test('warns about right and full joins', () { const right = 'SELECT * FROM demo RIGHT JOIN demo'; const full = 'SELECT * FROM demo NATURAL FULL JOIN demo'; minimumEngine.analyze(right).expectError('RIGHT JOIN', type: AnalysisErrorType.notSupportedInDesiredVersion); minimumEngine.analyze(full).expectError('NATURAL FULL JOIN', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(right).expectNoError(); currentEngine.analyze(full).expectNoError(); }); test('warns about aggregate functions with order by', () { const sql = "SELECT group_concat(content ORDER BY id) FROM demo"; minimumEngine.analyze(sql).expectError('ORDER BY id', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); } test/analysis/common_table_expressions_test.dart 644 0 0 6607 14612235271 20514 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('resolves columns from CTEs', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' WITH cte (foo, bar) AS (SELECT * FROM demo) SELECT * FROM cte; '''); expect(context.errors, isEmpty); final select = context.root as SelectStatement; expect(select.resolvedColumns!.map((c) => c.name), ['foo', 'bar']); expect( select.resolvedColumns!.map((c) => context.typeOf(c).type), [id.type, content.type], ); }); test('warns on column count mismatch', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' WITH cte (foo, bar, baz) AS (SELECT * FROM demo) SELECT 1; '''); expect(context.errors, hasLength(1)); final error = context.errors.single; expect(error.type, AnalysisErrorType.cteColumnCountMismatch); expect(error.message, stringContainsInOrder(['3', '2'])); }); test('handles recursive CTEs', () { final engine = SqlEngine(); final context = engine.analyze(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; '''); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final column = select.resolvedColumns!.single; final type = context.typeOf(column); expect(type.type, const ResolvedType(type: BasicType.int)); expect(column.name, 'x'); }); test('column references into CTE are case-insensitive', () async { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze(''' WITH shuffle_order AS ( SELECT ROWID, row_number() OVER (ORDER BY RANDOM()) rn FROM demo ) UPDATE demo SET content = (SELECT rn FROM shuffle_order WHERE shuffle_order.ROWID = demo.ROWID) - 1; '''); expect(result.errors, isEmpty); }); group('resolves CTEs for', () { late SqlEngine engine; setUp(() { engine = SqlEngine()..registerTable(demoTable); }); test('update statements', () { final result = engine.analyze('WITH x AS (SELECT * FROM demo) UPDATE demo ' 'SET content = x.content FROM x WHERE demo.id = x.id;'); expect(result.errors, isEmpty); }); test('update statements with column-name-list', () { final result = engine.analyze( 'WITH x AS (SELECT * FROM demo) UPDATE demo ' 'SET (id, content) = (x.id, x.content) FROM x WHERE demo.id = x.id;'); expect(result.errors, isEmpty); }); test('insert statements', () { final result = engine.analyze( 'WITH x AS (SELECT * FROM demo) INSERT INTO demo SELECT * FROM x;'); expect(result.errors, isEmpty); }); test('insert statements with upsert using column-name-list', () { final result = engine.analyze( 'WITH x AS (SELECT * FROM demo) INSERT INTO demo SELECT * FROM x ON CONFLICT(content) DO UPDATE SET (id, content) = (0, \'hello\');'); expect(result.errors, isEmpty); }); test('delete statements', () { final result = engine.analyze( 'WITH x AS (SELECT * FROM demo) DELETE FROM demo WHERE id IN (SELECT id FROM x);'); expect(result.errors, isEmpty); }); }); } test/analysis/available_tables_test.dart 644 0 0 3177 14370670576 16700 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('allows unqualified references to aliased table', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo d WHERE id'); expect(result.errors, isEmpty); }); test('does not allow references with wrong alias', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo d WHERE demo.id = 0'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.span?.text, 'span.text', 'demo.id') .having( (e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable), ); }); test('does not register the same result set multiple times', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTableFromSql(''' CREATE TABLE with_defaults ( a TEXT DEFAULT 'something', b INT UNIQUE ); ''') ..registerTableFromSql(''' CREATE TABLE with_constraints ( a TEXT, b INT NOT NULL, c FLOAT(10, 2), FOREIGN KEY (a, b) REFERENCES with_defaults (a, b) ); '''); final result = engine.analyze(r''' SELECT d.*, c.** FROM with_defaults d LEFT OUTER JOIN with_constraints c ON d.a = c.a AND d.b = c.b WHERE $predicate; '''); final scope = result.root.statementScope; expect(scope.resultSets, hasLength(2)); }); } test/analysis/schema 755 0 0 0 0 12266 5ustar0 pubpubtest/analysis/schema/column_test.dart 644 0 0 1676 14345646642 16164 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('isAliasForRowId', () { final engine = SqlEngine(); const schemaParser = SchemaFromCreateTable(); final isAlias = { 'CREATE TABLE x (id INTEGER PRIMARY KEY)': true, 'CREATE TABLE x (id INTEGER PRIMARY KEY) WITHOUT ROWID': false, 'CREATE TABLE x (id BIGINT PRIMARY KEY)': false, 'CREATE TABLE x (id INTEGER PRIMARY KEY DESC)': false, 'CREATE TABLE x (id INTEGER)': false, 'CREATE TABLE x (id INTEGER, PRIMARY KEY (id))': true, }; isAlias.forEach((createTblString, isAlias) { final parsed = engine.parse(createTblString).rootNode as CreateTableStatement; final table = schemaParser.read(parsed); expect( (table.findColumn('id') as TableColumn).isAliasForRowId(), isAlias, reason: '$createTblString: id is an alias? $isAlias', ); }); }); } test/analysis/schema/from_create_table_test.dart 644 0 0 20076 14623415614 20327 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../../common_data.dart'; import '../data.dart'; const _affinityTests = { 'INT': BasicType.int, 'INTEGER': BasicType.int, 'TINYINT': BasicType.int, 'SMALLINT': BasicType.int, 'MEDIUMINT': BasicType.int, 'BIGINT': BasicType.int, 'UNISGNED BIG INT': BasicType.int, 'INT2': BasicType.int, 'INT8': BasicType.int, 'CHARACTER(20)': BasicType.text, 'CHARACTER(255)': BasicType.text, 'VARYING CHARACTER(255)': BasicType.text, 'NCHAR(55)': BasicType.text, 'NATIVE CHARACTER(70)': BasicType.text, 'NVARCHAR(100)': BasicType.text, 'TEXT': BasicType.text, 'CLOB': BasicType.text, 'BLOB': BasicType.blob, null: BasicType.blob, 'REAL': BasicType.real, 'DOUBLE': BasicType.real, 'DOUBLE PRECISION': BasicType.real, 'FLOAT': BasicType.real, 'NUMERIC': BasicType.real, 'DECIMAL(10,5)': BasicType.real, 'BOOLEAN': BasicType.real, 'DATE': BasicType.real, 'DATETIME': BasicType.real, }; void main() { group('column type from SQL', () { const resolver = SchemaFromCreateTable(); test('affinity', () { _affinityTests.forEach((key, value) { expect(resolver.columnAffinity(key), equals(value), reason: '$key should have $value affinity'); }); }); test('any in a non-strict table', () { expect(resolver.resolveColumnType('ANY', isStrict: false).type, BasicType.real); }); test('any in a strict table', () { expect(resolver.resolveColumnType('ANY', isStrict: true).type, BasicType.any); }); }); test('export table structure', () { final engine = SqlEngine(); final stmt = engine.parse(createTableStmt).rootNode; final table = const SchemaFromCreateTable().read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.name), ['id', 'email', 'score', 'display_name']); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int), ResolvedType(type: BasicType.text), ResolvedType(type: BasicType.int), ResolvedType(type: BasicType.text, nullable: true), ]); expect(table.tableConstraints, hasLength(2)); }); test('reads isGenerated', () { final engine = SqlEngine(); final stmt = engine.parse(''' CREATE TABLE tbl ( a TEXT, b TEXT GENERATED ALWAYS AS (UPPER(b)) ); ''').rootNode; final table = const SchemaFromCreateTable().read(stmt as CreateTableStatement); expect( table.findColumn('a'), isA().having((e) => e.isGenerated, 'isGenerated', isFalse), ); expect( table.findColumn('b'), isA().having((e) => e.isGenerated, 'isGenerated', isTrue), ); }); test('supports booleans when drift extensions are enabled', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())); final stmt = engine.parse(''' CREATE TABLE foo ( a BOOL, b DATETIME, c DATE, d BOOLEAN NOT NULL, e INT64 ) ''').rootNode; final table = const SchemaFromCreateTable(driftExtensions: true) .read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int, hints: [IsBoolean()], nullable: true), ResolvedType(type: BasicType.int, hints: [IsDateTime()], nullable: true), ResolvedType(type: BasicType.int, hints: [IsDateTime()], nullable: true), ResolvedType(type: BasicType.int, hints: [IsBoolean()], nullable: false), ResolvedType(type: BasicType.int, hints: [IsBigInt()], nullable: true), ]); }); group('can read views', () { View readView(String sql) { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(sql); expect(context.errors, isEmpty); final stmt = context.root as CreateViewStatement; return const SchemaFromCreateTable().readView(context, stmt); } test('without column names', () { final view = readView('CREATE VIEW my_view AS SELECT * FROM demo;'); expect(view.name, 'my_view'); expect(view.resolvedColumns.map((e) => e.name), ['id', 'content']); expect( view.resolvedColumns.map((e) => e.type!.type), [BasicType.int, BasicType.text], ); }); test('with custom column names', () { final view = readView( 'CREATE VIEW another_view (foo, bar) AS SELECT * FROM demo;'); expect(view.name, 'another_view'); expect(view.resolvedColumns.map((e) => e.name), ['foo', 'bar']); }); test('with WITH clause', () { final view = readView('CREATE VIEW my_view AS ' 'WITH foo AS (SELECT * FROM demo) SELECT * FROM foo;'); expect(view.name, 'my_view'); expect(view.resolvedColumns.map((e) => e.name), ['id', 'content']); }); }); test('can read columns without type name', () { final engine = SqlEngine(); final stmt = engine.parse('CREATE TABLE foo (id);').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.type, BasicType.blob); }); test('aliases to rowid are non-nullable', () { final engine = SqlEngine(); final stmt = engine.parse('CREATE TABLE foo (id INTEGER PRIMARY KEY);').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type, const ResolvedType(type: BasicType.int, nullable: false)); }); group('the primary key of a STRICT table is non-nullable', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); test('when declared on the column', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT PRIMARY KEY) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); test('when declared on the table', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT, PRIMARY KEY (bar)) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); test('even when it has a NULL constraint', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT NULL, PRIMARY KEY (bar)) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); }); test('resolves types in strict tables', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); final stmt = engine.parse(''' CREATE TABLE foo ( a INTEGER PRIMARY KEY, b TEXT, c ANY ) STRICT; ''').rootNode; final table = const SchemaFromCreateTable().read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.name), ['a', 'b', 'c']); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int), ResolvedType(type: BasicType.text, nullable: true), ResolvedType(type: BasicType.any, nullable: true), ]); }); group('sets withoutRowid and isStrict', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); void testWith(String suffix, bool withoutRowid, bool strict) { final stmt = engine.parse('CREATE TABLE foo (bar TEXT) $suffix;').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.withoutRowId, withoutRowid); expect(table.isStrict, strict); } test('when the table is neither', () { testWith('', false, false); }); test('when the table is without rowid', () { testWith('WITHOUT ROWID', true, false); }); test('when the table is strict', () { testWith('STRICT', false, true); }); test('when the table is both', () { testWith('WITHOUT ROWID, STRICT', true, true); testWith('STRICT, WITHOUT ROWID', true, true); }); }); } test/analysis/schema/table_test.dart 644 0 0 2156 14345646642 15750 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { group('finds columns', () { final engine = SqlEngine(); const schemaParser = SchemaFromCreateTable(); Column? findWith(String createTbl, String columnName) { final stmt = engine.parse(createTbl).rootNode as CreateTableStatement; final table = schemaParser.read(stmt); return table.findColumn(columnName); } test('when declared in table', () { expect(findWith('CREATE TABLE x (__rowid__ VARCHAR)', '__rowid__'), isA()); }); test('when alias to rowid', () { final column = findWith('CREATE TABLE x (id INTEGER PRIMARY KEY)', 'oid'); expect(column?.name, 'id'); expect(column, isA()); }); test('when virtual rowid column', () { final column = findWith('CREATE TABLE x (id VARCHAR)', 'oid'); expect(column, isA()); }); test('when not found', () { final column = findWith( 'CREATE TABLE x (id INTEGER PRIMARY KEY) WITHOUT ROWID', 'oid'); expect(column, isNull); }); }); } test/analysis/reference_resolver_test.dart 644 0 0 32552 14612235271 17310 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; import 'data.dart'; import 'errors/utils.dart'; void main() { test('correctly resolves return columns', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT id, d.content, *, 3 + 4 FROM demo AS d ' 'WHERE _rowid_ = 3'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(context.errors, isEmpty); expect(resolvedColumns.map((c) => c.name), ['id', 'content', 'id', 'content', '3 + 4']); expect(resolvedColumns.map((c) => context.typeOf(c).type!.type), [ BasicType.int, BasicType.text, BasicType.int, BasicType.text, BasicType.int, ]); final firstColumn = select.columns[0] as ExpressionResultColumn; final secondColumn = select.columns[1] as ExpressionResultColumn; final from = select.from as TableReference; expect((firstColumn.expression as Reference).resolvedColumn?.source, id); expect( (secondColumn.expression as Reference).resolvedColumn?.source, content); expect(from.resultSet?.unalias(), demoTable); final where = select.where as BinaryExpression; expect((where.left as Reference).resolved, id); }); test('resolves columns from views', () { final engine = SqlEngine()..registerTable(demoTable); final viewCtx = engine.analyze('CREATE VIEW my_view (foo, bar) AS ' 'SELECT * FROM demo;'); engine.registerView(engine.schemaReader .readView(viewCtx, viewCtx.root as CreateViewStatement)); final context = engine.analyze('SELECT * FROM my_view'); expect(context.errors, isEmpty); final resolvedColumns = (context.root as SelectStatement).resolvedColumns!; expect(resolvedColumns.map((e) => e.name), ['foo', 'bar']); expect( resolvedColumns.map((e) => context.typeOf(e).type!.type), [BasicType.int, BasicType.text], ); }); test("resolved columns don't include drift nested results", () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTable(demoTable); final context = engine.analyze('SELECT demo.** FROM demo;'); expect(context.errors, isEmpty); expect((context.root as SelectStatement).resolvedColumns, isEmpty); }); test('resolves the column for order by clauses', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine .analyze('SELECT d.content, 3 * d.id AS t FROM demo AS d ORDER BY t'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final term = (select.orderBy as OrderBy).terms.single as OrderingTerm; final expression = term.expression as Reference; final resolved = expression.resolved as ExpressionColumn; enforceEqual( resolved.expression, BinaryExpression( NumericLiteral(3), token(TokenType.star), Reference(entityName: 'd', columnName: 'id'), ), ); }); test('allows references to result column in group by', () { // https://github.com/simolus3/drift/issues/2378 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE foo (bar INTEGER);'); final result = engine.analyze(''' SELECT *, bar > 20 AS test FROM foo GROUP BY bar HAVING test '''); expect(result.errors, isEmpty); }); test('does not allow references to result column outside of ORDER BY', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine .analyze('SELECT d.content, 3 * d.id AS t, t AS u FROM demo AS d'); context.expectError('t', type: AnalysisErrorType.referencedUnknownColumn); }); test('resolves columns from nested results', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTable(demoTable) ..registerTable(anotherTable); final context = engine.analyze('SELECT SUM(*) AS rst FROM ' '(SELECT COUNT(*) FROM demo UNION ALL SELECT COUNT(*) FROM tbl);'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; expect(select.resolvedColumns, hasLength(1)); expect( context.typeOf(select.resolvedColumns!.single).type!.type, BasicType.int, ); }); test('resolves columns in nested queries', () { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTable(demoTable); final context = engine.analyze('SELECT content, LIST(SELECT id FROM demo) FROM demo'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final nestedQuery = select.columns[1] as NestedQueryColumn; expect(nestedQuery.select.columns, hasLength(1)); expect( context.typeOf(nestedQuery.select.resolvedColumns!.single).type!.type, BasicType.int, ); }); group('reports correct column name for rowid aliases', () { final engine = SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); test('when virtual id', () { final context = engine.analyze('SELECT oid, _rowid_ FROM tbl'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(resolvedColumns.map((c) => c.name), ['rowid', 'rowid']); }); test('when alias to actual column', () { final context = engine.analyze('SELECT oid, _rowid_ FROM demo'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(resolvedColumns.map((c) => c.name), ['id', 'id']); }); }); group('sub-queries', () { test('are resolved', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze( 'SELECT d.*, (SELECT id FROM demo WHERE id = d.id) FROM demo d;'); expect(context.errors, isEmpty); }); test('cannot refer to outer tables if used in FROM', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze( 'SELECT d.* FROM demo d, (SELECT * FROM demo WHERE id = d.id);'); context.expectError('d.id', type: AnalysisErrorType.referencedUnknownTable); }); test('can refer to CTEs if used in FROM', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('WITH cte AS (SELECT * FROM demo) ' 'SELECT d.* FROM demo d, (SELECT * FROM cte);'); expect(context.errors, isEmpty); }); test('can nest and see outer tables if that is a subquery', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' SELECT (SELECT * FROM demo "inner", (SELECT * FROM demo WHERE "inner".id = "outer".id) ) FROM demo "outer"; '''); // note that "outer".id is visible and should not report an error context.expectError('"inner".id', type: AnalysisErrorType.referencedUnknownTable); }); test('nested via FROM cannot see outer result sets', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' SELECT * FROM demo "outer", (SELECT * FROM demo "inner", (SELECT * FROM demo WHERE "inner".id = "outer".id)) '''); expect( context.errors, [ analysisErrorWith( lexeme: '"inner".id', type: AnalysisErrorType.referencedUnknownTable, ), analysisErrorWith( lexeme: '"outer".id', type: AnalysisErrorType.referencedUnknownTable, ), ], ); }); }); test('resolves sub-queries as data sources', () { final engine = SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); final context = engine.analyze('SELECT d.* FROM demo d INNER JOIN tbl ' 'ON tbl.id = (SELECT id FROM tbl WHERE date = ? AND id = d.id)'); expect(context.errors, isEmpty); }); test('resolves window declarations', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' SELECT row_number() OVER wnd FROM demo WINDOW wnd AS (PARTITION BY content GROUPS CURRENT ROW EXCLUDE TIES) '''); final column = (context.root as SelectStatement).resolvedColumns!.single as ExpressionColumn; final over = (column.expression as WindowFunctionInvocation).over!; enforceEqual( over, WindowDefinition( partitionBy: [Reference(columnName: 'content')], frameSpec: FrameSpec( type: FrameType.groups, start: FrameBoundary.currentRow(), excludeMode: ExcludeMode.ties, ), ), ); }); test('warns about ambigious references', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT id FROM demo, (SELECT id FROM demo) AS a'); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having((e) => e.type, 'type', AnalysisErrorType.ambiguousReference) .having((e) => e.span?.text, 'span.text', 'id'), ); }); test("does not allow columns from tables that haven't been added", () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT demo.id;'); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having( (e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span?.text, 'span.text', 'demo.id')); }); group('nullability for references from outer join', () { final engine = SqlEngine() ..registerTableFromSql(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY ); ''') ..registerTableFromSql(''' CREATE TABLE messages ( sender INTEGER NOT NULL ); '''); void testWith(String sql) { final context = engine.analyze(sql); expect(context.errors, isEmpty); final columns = (context.root as SelectStatement).resolvedColumns!; expect(columns.map((e) => e.name), ['sender', 'id']); expect(context.typeOf(columns[0]).nullable, isFalse); expect(context.typeOf(columns[1]).nullable, isTrue); } test('unaliased columns, unaliased tables', () { testWith('SELECT sender, id FROM messages ' 'LEFT JOIN users ON id = sender'); }); test('unaliased columns, aliased tables', () { testWith('SELECT sender, id FROM messages m ' 'LEFT JOIN users u ON id = sender'); }); test('aliased columns, unaliased tables', () { testWith('SELECT messages.sender, users.id FROM messages ' 'LEFT JOIN users ON id = sender'); }); test('aliased columns, aliased tables', () { testWith('SELECT m.*, u.* FROM messages m ' 'LEFT JOIN users u ON u.id = m.sender'); }); test('single star, aliased tables', () { testWith('SELECT * FROM messages m ' 'LEFT JOIN users u ON u.id = m.sender'); }); test('single star, unaliased tables', () { testWith('SELECT * FROM messages ' 'LEFT JOIN users ON id = sender'); }); }); group('join analysis keeps column non-nullable', () { void testWith(String sql) { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTableFromSql(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY ); '''); final result = engine.analyze(sql); expect(result.errors, isEmpty); final root = result.root as StatementReturningColumns; expect( root.returnedResultSet!.resolvedColumns! .map((e) => result.typeOf(e).type), everyElement( isA().having((e) => e.nullable, 'nullable', isFalse)), ); } test('for reference to table in INSERT', () { testWith('INSERT INTO users VALUES (?) RETURNING id;'); }); test('for reference to table in UPDATE', () { testWith('UPDATE users SET id = id + 1 RETURNING id;'); }); test('for reference to table in DELETE', () { testWith('DELETE FROM users RETURNING id;'); }); }); test('resolves column in foreign key declaration', () { final engine = SqlEngine()..registerTableFromSql(''' CREATE TABLE points ( id INTEGER NOT NULL PRIMARY KEY, lat REAL NOT NULL, long REAL NOT NULL ); '''); final parseResult = engine.parse(''' CREATE TABLE routes ( route_id INTEGER NOT NULL PRIMARY KEY, "from" INTEGER NOT NULL REFERENCES points (id), "to" INTEGER NOT NULL REFERENCES points (id) ); '''); final table = const SchemaFromCreateTable() .read(parseResult.rootNode as CreateTableStatement); engine.registerTable(table); final result = engine.analyzeParsed(parseResult); result.expectNoError(); final createTable = result.root as CreateTableStatement; final fromReference = createTable.columns[1].constraints[1] as ForeignKeyColumnConstraint; final fromReferenced = fromReference.clause.columnNames.single.resolvedColumn; expect(fromReferenced, isNotNull); expect(fromReferenced!.source.containingSet, result.rootScope.knownTables['points']); }); } test/analysis/column_resolver_test.dart 644 0 0 25626 14623415614 16656 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; import 'errors/utils.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)); engine.registerTable(demoTable); }); group('CREATE TRIGGER statements', () { group('delete', () { test('can use OLD references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON demo BEGIN SELECT * FROM demo WHERE id = old.id; END; '''); expect(context.errors, isEmpty); }); test("can't use NEW references", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON demo BEGIN SELECT * FROM demo WHERE id = new.id; END; '''); expect( context.errors, contains(analysisErrorWith( type: AnalysisErrorType.referencedUnknownTable, lexeme: 'new.id')), ); }); }); group('insert', () { test('can use NEW references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE INSERT ON demo BEGIN SELECT * FROM demo WHERE id = new.id; END; '''); expect(context.errors, isEmpty); }); test("can't use OLD references", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE INSERT ON demo BEGIN SELECT * FROM demo WHERE id = old.id; END; '''); expect( context.errors, contains(analysisErrorWith( type: AnalysisErrorType.referencedUnknownTable, lexeme: 'old.id')), ); }); }); test('update can use NEW and OLD references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE UPDATE ON demo BEGIN SELECT * FROM demo WHERE id = new.id; INSERT INTO demo VALUES (1, old.content); END; '''); expect(context.errors, isEmpty); }); test('can refer to column in UPDATE OF', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE UPDATE OF content ON DEMO BEGIN SELECT * FROM demo; END; '''); expect(context.errors, isEmpty); }); test("can't use unqualified reference", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON DEMO WHEN id < 10 BEGIN SELECT * FROM demo; END; '''); expect(context.errors, [ analysisErrorWith( lexeme: 'id', type: AnalysisErrorType.referencedUnknownColumn) ]); }); test("can't select from alias", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON demo BEGIN SELECT * FROM old; END; '''); expect(context.errors, [ analysisErrorWith( lexeme: 'old', type: AnalysisErrorType.referencedUnknownTable) ]); }); }); test('resolves index', () { final context = engine.analyze('CREATE INDEX foo ON demo (content)'); context.expectNoError(); final tableReference = context.root.allDescendants.whereType().first; final columnReference = context.root.allDescendants .whereType() .first .expression as Reference; expect(tableReference.resolved, demoTable); expect(columnReference.resolvedColumn, isA()); }); test("DO UPDATE action in upsert can refer to 'exluded'", () { final context = engine.analyze(''' INSERT INTO demo VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET content = content || excluded.content; '''); expect(context.errors, isEmpty); }); test('columns in an insert cannot refer to table', () { engine .analyze('INSERT INTO demo (content) VALUES (demo.content)') .expectError('demo.content'); }); test('columns from values statement', () { final context = engine.analyze("VALUES ('foo', 3), ('bar', 5)"); expect(context.errors, isEmpty); final columns = (context.root as ResultSet).resolvedColumns!; expect(columns.map((e) => e.name), ['Column1', 'Column2']); expect(columns.map((e) => context.typeOf(e).type?.type), [BasicType.text, BasicType.int]); }); test('columns from nested VALUES', () { final context = engine.analyze('SELECT Column1 FROM (VALUES (3))'); expect(context.errors, isEmpty); }); test('joining table with and without alias', () { final context = engine.analyze(''' SELECT * FROM demo a JOIN demo ON demo.id = a.id '''); context.expectNoError(); }); test("from clause can't use its own table aliases", () { final context = engine.analyze(''' SELECT * FROM demo a JOIN a b ON b.id = a.id '''); expect(context.errors, [ analysisErrorWith( lexeme: 'a b', type: AnalysisErrorType.referencedUnknownTable), analysisErrorWith( lexeme: 'b.id', type: AnalysisErrorType.referencedUnknownTable), ]); }); test('can use columns from deleted table', () { engine.analyze('DELETE FROM demo WHERE demo.id = 2').expectNoError(); }); test('gracefully handles tuples of different lengths in VALUES', () { final context = engine.analyze("VALUES ('foo', 3), ('bar')"); expect(context.errors, isNotEmpty); final columns = (context.root as ResultSet).resolvedColumns!; expect(columns.map((e) => e.name), ['Column1', 'Column2']); expect(columns.map((e) => context.typeOf(e).type?.type), [BasicType.text, BasicType.int]); }); test('handles update statement with from clause', () { // Example from here: https://www.sqlite.org/lang_update.html#upfrom engine ..registerTableFromSql(''' CREATE TABLE inventory ( itemId INTEGER PRIMARY KEY, quantity INTEGER NOT NULL DEFAULT 0, ); ''') ..registerTableFromSql(''' CREATE TABLE sales ( itemId INTEGER NOT NULL, quantity INTEGER NOT NULL, ); '''); final result = engine.analyze(''' UPDATE inventory SET quantity = quantity - daily.amt FROM (SELECT sum(quantity) AS amt, itemId FROM sales GROUP BY 2) AS daily WHERE inventory.itemId = daily.itemId; '''); expect(result.errors, isEmpty); }); group('resolves RETURNING clause', () { test('for simple inserts', () { final result = engine .analyze("INSERT INTO demo (content) VALUES ('hi') RETURNING *;"); final returning = (result.root as InsertStatement).returnedResultSet; expect(returning, isNotNull); expect(returning!.resolvedColumns!.map((e) => e.name), ['id', 'content']); }); test('for custom expressions', () { final result = engine.analyze("INSERT INTO demo (content) VALUES ('hi') " 'RETURNING content || content AS x;'); final returning = (result.root as InsertStatement).returnedResultSet!; expect(returning.resolvedColumns!.map((e) => e.name), ['x']); }); test('star does not include other tables', () { final result = engine.analyze(''' UPDATE demo SET content = '' FROM (SELECT * FROM demo) AS old RETURNING *; '''); final returning = (result.root as UpdateStatement).returnedResultSet!; expect(returning.resolvedColumns!.map((e) => e.name), ['id', 'content']); }); test('can refer to columns from other tables', () { final result = engine.analyze(''' UPDATE demo SET content = '' FROM (SELECT * FROM demo) AS old RETURNING old.id, old.content; '''); expect(result.errors, isEmpty); }); }); test('reports error when using star wihout tables', () { final result = engine.analyze('SELECT 1, 2, *;'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having( (e) => e.type, 'type', AnalysisErrorType.starColumnWithoutTable) .having((e) => e.source?.span?.text, 'source.span?.text', '*'), ); }); group('resolves target columns of INSERT', () { test('for regular tables', () { final root = engine.analyze('INSERT INTO demo VALUES (?, ?)').root as InsertStatement; expect(root.resolvedTargetColumns, hasLength(2)); }); test('when there are generated columns', () { engine.registerTableFromSql(''' CREATE TABLE x ( a TEXT NOT NULL, b TEXT GENERATED ALWAYS AS (a) ); '''); final root = engine.analyze('INSERT INTO x VALUES (?, ?)').root as InsertStatement; expect(root.resolvedTargetColumns, hasLength(1)); }); }); test('does not allow a subquery in from to read outer values', () { final result = engine.analyze( 'SELECT * FROM demo d1, (SELECT * FROM demo i WHERE i.id = d1.id) d2;'); result.expectError('d1.id', type: AnalysisErrorType.referencedUnknownTable); }); test('allows subquery expressions to read outer values', () { final result = engine.analyze('SELECT * FROM demo d1 WHERE ' 'EXISTS (SELECT * FROM demo i WHERE i.id = d1.id);'); result.expectNoError(); }); test('names for alias to rowid', () { final outer = engine.analyze('SELECT RoWiD FROM demo').root as SelectStatement; expect(outer.resolvedColumns?.map((e) => e.name), ['id']); // These aliases somehow aren't renamed in nested queries final subquery = engine .analyze('SELECT * FROM (SELECT RoWiD FROM demo)') .root as SelectStatement; expect(subquery.resolvedColumns?.map((e) => e.name), ['RoWiD']); final cte = engine .analyze('WITH x AS (SELECT RoWiD FROM demo) SELECT * FROM x') .root as SelectStatement; expect(cte.resolvedColumns?.map((e) => e.name), ['RoWiD']); }); test('reports error for circular reference', () { final query = engine.analyze('WITH x AS (SELECT * FROM x) SELECT 1;'); expect(query.errors, [ analysisErrorWith(lexeme: 'x', type: AnalysisErrorType.circularReference), ]); }); test('regression test for #2453', () { // https://github.com/simolus3/drift/issues/2453 engine ..registerTableFromSql('CREATE TABLE persons (id INTEGER);') ..registerTableFromSql('CREATE TABLE cars (driver INTEGER);'); final query = engine.analyze(''' SELECT * FROM cars JOIN persons second_person ON second_person.id = cars.driver JOIN persons ON persons.id = cars.driver; '''); query.expectNoError(); }); test('expands star columns', () { final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE foo (bar INTEGER);'); final result = engine.analyze("SELECT 'client' literal, * FROM foo;"); final select = result.root as SelectStatement; expect(select.resolvedColumns?.map((e) => e.name), ['literal', 'bar']); }); test('error for nonexisting table in IN expression', () { final query = engine.analyze('SELECT 1 IN no_such_table'); query.expectError('no_such_table', type: AnalysisErrorType.referencedUnknownTable); }); } test/analysis/variable_indexing_test.dart 644 0 0 1470 14345646642 17071 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('resolves index of variables', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT ? = :test FROM demo LIMIT ?4 OFFSET ?;'); // indices: 1 2 4 5 final select = context.root as SelectStatement; final firstEquals = (select.columns[0] as ExpressionResultColumn).expression as BinaryExpression; final limit = select.limit as Limit; expect((firstEquals.left as Variable).resolvedIndex, 1); expect((firstEquals.right as Variable).resolvedIndex, 2); expect((limit.count as Variable).resolvedIndex, 4); expect((limit.offset as Variable).resolvedIndex, 5); }); } test/analysis/types2 755 0 0 0 0 12254 5ustar0 pubpubtest/analysis/types2/resolver_test.dart 644 0 0 35201 14711507160 16511 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTable(demoTable) ..registerTable(anotherTable); TypeResolver obtainResolver(String sql, {AnalyzeStatementOptions? options}) { final context = engine.analyze(sql, stmtOptions: options); return TypeResolver(TypeInferenceSession(context))..run(context.root); } Iterable resolveVariableTypes(String sql, {AnalyzeStatementOptions? options}) { final resolver = obtainResolver(sql, options: options); final session = resolver.session; return session.context.root.allDescendants .whereType() .map((variable) => session.typeOf(variable)); } ResolvedType? resolveFirstVariable(String sql, {AnalyzeStatementOptions? options}) { return resolveVariableTypes(sql, options: options).first; } ResolvedType? resolveResultColumn(String sql) { final resolver = obtainResolver(sql); final session = resolver.session; final stmt = session.context.root as SelectStatement; return session.typeOf(stmt.resolvedColumns!.single); } test('resolves literals', () { expect(resolveResultColumn('SELECT NULL'), const ResolvedType(type: BasicType.nullType, nullable: true)); expect(resolveResultColumn('SELECT TRUE'), const ResolvedType.bool()); expect(resolveResultColumn("SELECT x''"), const ResolvedType(type: BasicType.blob)); expect(resolveResultColumn("SELECT ''"), const ResolvedType(type: BasicType.text)); expect(resolveResultColumn('SELECT 3'), const ResolvedType(type: BasicType.int)); expect(resolveResultColumn('SELECT 3.5'), const ResolvedType(type: BasicType.real)); }); test('infers boolean type in where conditions', () { expect(resolveFirstVariable('SELECT * FROM demo WHERE :foo'), const ResolvedType.bool()); }); test('does not infer boolean for grandchildren of where clause', () { expect(resolveFirstVariable("SELECT * FROM demo WHERE 'foo' = :foo"), const ResolvedType(type: BasicType.text)); }); test('infers boolean type in a join ON clause', () { expect( resolveFirstVariable('SELECT * FROM demo JOIN tbl ON :foo'), const ResolvedType.bool(), ); }); test('infers type in a string concatenation', () { expect(resolveFirstVariable("SELECT '' || :foo"), const ResolvedType(type: BasicType.text)); }); test('resolves arithmetic expressions', () { expect(resolveFirstVariable('SELECT ((3 + 4) * 5) = ?'), const ResolvedType(type: BasicType.int)); }); group('cast expressions', () { test('resolve to type argument', () { expect(resolveResultColumn('SELECT CAST(3+4 AS TEXT)'), const ResolvedType(type: BasicType.text)); }); test('allow anything as their operand', () { expect(resolveFirstVariable('SELECT CAST(? AS TEXT)'), null); }); }); group('iif', () { test('has type of arguments', () { expect(resolveResultColumn('SELECT IIF(false, 0, 1)'), const ResolvedType(type: BasicType.int)); }); test('is nullable if argument is', () { expect(resolveResultColumn('SELECT IIF(false, NULL, 1)'), const ResolvedType(type: BasicType.int, nullable: true)); }); test('is not nullable just because the condition is', () { expect(resolveResultColumn('SELECT IIF(NULL, 0, 1)'), const ResolvedType(type: BasicType.int)); }); test('infers one argument based on the other', () { expect(resolveFirstVariable('SELECT IIF(false, ?, 1)'), const ResolvedType(type: BasicType.int)); expect(resolveFirstVariable('SELECT IIF(false, 0, ?)'), const ResolvedType(type: BasicType.int)); }); test('infers condition', () { expect(resolveFirstVariable('SELECT IIF(?, 0, 1)'), const ResolvedType(type: BasicType.int, hints: [IsBoolean()])); }); }); group('types in insert statements', () { test('for VALUES', () { final resolver = obtainResolver('INSERT INTO demo VALUES (:id, :content);'); final root = resolver.session.context.root; final variables = root.allDescendants.whereType(); final idVar = variables.singleWhere((v) => v.resolvedIndex == 1); final contentVar = variables.singleWhere((v) => v.resolvedIndex == 2); expect(resolver.session.typeOf(idVar), id.type); expect(resolver.session.typeOf(contentVar), content.type); }); test('for SELECT', () { final resolver = obtainResolver('INSERT INTO demo SELECT :id, :content'); final root = resolver.session.context.root; final variables = root.allDescendants.whereType(); final idVar = variables.singleWhere((v) => v.resolvedIndex == 1); final contentVar = variables.singleWhere((v) => v.resolvedIndex == 2); expect(resolver.session.typeOf(idVar), id.type); expect(resolver.session.typeOf(contentVar), content.type); }); }); test('recognizes that variables are the same', () { // semantically, :var and ?1 are the same variable final type = resolveFirstVariable('SELECT :var WHERE ?1'); expect(type, const ResolvedType.bool()); }); test('respects variable types set from options', () { const type = ResolvedType(type: BasicType.text); // should resolve to string, even though it would be a boolean normally final found = resolveFirstVariable( 'SELECT * FROM demo WHERE ?', options: const AnalyzeStatementOptions(indexedVariableTypes: {1: type}), ); expect(found, type); }); test('handles LIMIT clauses', () { const int = ResolvedType(type: BasicType.int); final type = resolveFirstVariable('SELECT 0 LIMIT ?'); expect(type, int); final offsetType = resolveFirstVariable('SELECT 0 LIMIT 1, ?'); expect(offsetType, int); }); test('handles string matching expressions', () { final type = resolveFirstVariable('SELECT * FROM demo WHERE content LIKE ?'); expect(type, const ResolvedType(type: BasicType.text)); final escapedType = resolveFirstVariable( "SELECT * FROM demo WHERE content LIKE 'foo' ESCAPE ?"); expect(escapedType, const ResolvedType(type: BasicType.text)); }); group('function', () { test('timediff', () { final resultType = resolveResultColumn('SELECT timediff(?, ?)'); final argType = resolveFirstVariable('SELECT timediff(?, ?)'); expect(resultType, const ResolvedType(type: BasicType.text)); expect(argType, const ResolvedType(type: BasicType.text, hints: [IsDateTime()])); }); test('octet_length', () { expect(resolveResultColumn('SELECT octet_length(?)'), equals(const ResolvedType(type: BasicType.int))); }); test('nth_value', () { final resolver = obtainResolver("SELECT nth_value('string', ?1) = ?2"); final variables = resolver.session.context.root.allDescendants .whereType() .iterator; variables.moveNext(); final firstVar = variables.current; variables.moveNext(); final secondVar = variables.current; expect(resolver.session.typeOf(firstVar), equals(const ResolvedType(type: BasicType.int))); expect(resolver.session.typeOf(secondVar), equals(const ResolvedType(type: BasicType.text))); }); }); group('case expressions', () { test('infers base clause from when', () { final type = resolveFirstVariable("SELECT CASE ? WHEN 1 THEN 'two' END"); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers when condition from base', () { final type = resolveFirstVariable("SELECT CASE 1 WHEN ? THEN 'two' END"); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers when conditions as boolean when no base is set', () { final type = resolveFirstVariable("SELECT CASE WHEN ? THEN 'two' END;"); expect(type, const ResolvedType.bool()); }); test('infers type of whole when expression', () { final type = resolveResultColumn("SELECT CASE WHEN false THEN 'one' " "WHEN true THEN 'two' ELSE 'three' END;"); expect(type, const ResolvedType(type: BasicType.text)); }); }); test('can select columns', () { final type = resolveResultColumn('SELECT id FROM demo;'); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers type of EXISTS expressions', () { final type = resolveResultColumn('SELECT EXISTS(SELECT * FROM demo);'); expect(type, const ResolvedType.bool()); }); test('resolves subqueries', () { expect( resolveResultColumn('SELECT (SELECT COUNT(*) FROM demo);'), const ResolvedType(type: BasicType.int, nullable: false), ); expect( resolveResultColumn('SELECT (SELECT id FROM demo);'), const ResolvedType(type: BasicType.int, nullable: true), ); expect( resolveResultColumn('SELECT (SELECT COUNT(*) == 0 FROM demo);'), const ResolvedType.bool(nullable: false), ); expect( resolveResultColumn( 'SELECT (SELECT COUNT(*) == 0 FROM demo GROUP BY id);'), const ResolvedType.bool(nullable: true), ); expect( resolveResultColumn('SELECT (SELECT IFNULL(MIN(id), 0) FROM demo);'), const ResolvedType(type: BasicType.int, nullable: false), ); expect( resolveResultColumn( 'SELECT (SELECT IFNULL(CAST(SUM(id) AS INT), 0) FROM demo);'), const ResolvedType(type: BasicType.int, nullable: false), ); }); test('infers types for dart placeholders', () { final resolver = obtainResolver(r'SELECT * FROM demo WHERE $pred'); final type = resolver.session.typeOf(resolver .session.context.root.allDescendants .firstWhere((e) => e is DartExpressionPlaceholder) as DartExpressionPlaceholder); expect(type, const ResolvedType.bool()); }); test('supports unions', () { void check(String sql) { final resolver = obtainResolver(sql); final column = (resolver.session.context.root as CompoundSelectStatement) .resolvedColumns! .single; final type = resolver.session.typeOf(column)!; expect(type.type, BasicType.text); expect(type.nullable, isTrue); } check("SELECT 'foo' AS r UNION ALL SELECT NULL AS r"); check("SELECT NULL AS r UNION ALL SELECT 'foo' AS r"); }); test('handles recursive CTEs', () { final type = resolveResultColumn(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt '''); expect(type, const ResolvedType(type: BasicType.int)); }); test('handles set components in updates', () { final type = resolveFirstVariable('UPDATE demo SET id = ?'); expect(type, const ResolvedType(type: BasicType.int)); }); test('handles multi column set components in updates', () { final variableTypes = resolveVariableTypes('UPDATE demo SET (id, content) = (?, ?)'); expect(variableTypes.first, const ResolvedType(type: BasicType.int)); expect( variableTypes.elementAt(1), const ResolvedType(type: BasicType.text)); }); test('handles multi column set components in updates with select subquery', () { final variableTypes = resolveVariableTypes('UPDATE demo SET (id, content) = (SELECT ?,?)'); expect(variableTypes.first, const ResolvedType(type: BasicType.int)); expect( variableTypes.elementAt(1), const ResolvedType(type: BasicType.text)); }); test('handles multi column set components in updates with values subquery', () { final variableTypes = resolveVariableTypes('UPDATE demo SET (id, content) = (VALUES(?,?))'); expect(variableTypes.first, const ResolvedType(type: BasicType.int)); expect( variableTypes.elementAt(1), const ResolvedType(type: BasicType.text)); }); test('infers offsets in frame specs', () { final type = resolveFirstVariable('SELECT SUM(id) OVER (ROWS ? PRECEDING)'); expect(type, const ResolvedType(type: BasicType.int)); }); test('resolves type hints from between expressions', () { const dateTime = ResolvedType(type: BasicType.int, hints: [IsDateTime()]); final session = obtainResolver( 'SELECT 1 WHERE :date BETWEEN :start AND :end', options: const AnalyzeStatementOptions( namedVariableTypes: {':date': dateTime}, ), ).session; Variable? start, end; for (final variable in session.context.root.allDescendants .whereType()) { if (variable.name == ':start') start = variable; if (variable.name == ':end') end = variable; } assert(start != null && end != null); expect(session.typeOf(start!), dateTime); expect(session.typeOf(end!), dateTime); }); group('IS IN expressions', () { test('infer the variable as an array type', () { final type = resolveFirstVariable('SELECT 3 IN ?'); expect(type, const ResolvedType(type: BasicType.int, isArray: true)); }); test('does not infer the variable as an array when in a tuple', () { final type = resolveFirstVariable('SELECT 3 IN (?)'); expect(type, const ResolvedType(type: BasicType.int, isArray: false)); }); }); test('columns from LEFT OUTER joins are nullable', () { final resolver = obtainResolver(''' WITH sq_1 (one ) AS (SELECT 1), sq_2 (two) AS (SELECT 2), sq_3 (three) AS (SELECT 3) SELECT one, two, three FROM sq_1 LEFT JOIN sq_2 LEFT OUTER JOIN sq_3 '''); final session = resolver.session; final stmt = resolver.session.context.root as SelectStatement; final columns = stmt.resolvedColumns!; expect(session.typeOf(columns[0]), const ResolvedType(type: BasicType.int)); expect(session.typeOf(columns[1]), const ResolvedType(type: BasicType.int, nullable: true)); expect(session.typeOf(columns[2]), const ResolvedType(type: BasicType.int, nullable: true)); }); test('analyzes nested columns', () { engine.registerTableFromSql(''' CREATE TABLE x ( id INTEGER NOT NULL, other INTEGER ); '''); final resolver = obtainResolver(''' SELECT xxx.id FROM ( SELECT * FROM ( SELECT id FROM x ) xx ) xxx; '''); final session = resolver.session; final stmt = resolver.session.context.root as SelectStatement; final columns = stmt.resolvedColumns!; expect(columns, hasLength(1)); expect(session.typeOf(columns[0]), const ResolvedType(type: BasicType.int, nullable: false)); }); } test/analysis/types2/join_analysis_test.dart 644 0 0 1561 14612235271 17475 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('correctly reports results for aliases', () { final engine = SqlEngine()..registerTable(demoTable); final stmt = engine.analyze(''' SELECT a1.*, a2.* FROM demo AS a1 LEFT JOIN demo AS a2 ON FALSE INNER JOIN demo AS a3 ON TRUE; ''').root; final model = JoinModel.of(stmt)!; expect( model.isNullableTable( stmt.scope.resolveResultSetForReference('a1')!.resultSet.resultSet!), isFalse, ); expect( model.isNullableTable( stmt.scope.resolveResultSetForReference('a2')!.resultSet.resultSet!), isTrue, ); expect( model.isNullableTable( stmt.scope.resolveResultSetForReference('a3')!.resultSet.resultSet!), isFalse, ); }); } test/analysis/types2/misc_cases_test.dart 644 0 0 16315 14720702252 16765 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; // Cases copied from the regular type inference algorithm test const Map _types = { 'SELECT * FROM demo WHERE id = ?': ResolvedType(type: BasicType.int), 'SELECT * FROM demo WHERE content = ?': ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content == ?': ResolvedType(type: BasicType.text), 'SELECT * FROM demo LIMIT ?': ResolvedType(type: BasicType.int), 'SELECT 1 FROM demo GROUP BY id HAVING COUNT(*) = ?': ResolvedType(type: BasicType.int), 'SELECT 1 FROM demo WHERE id BETWEEN 3 AND ?': ResolvedType(type: BasicType.int), 'UPDATE demo SET content = ? WHERE id = 3': ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content LIKE ?': ResolvedType(type: BasicType.text), "SELECT * FROM demo WHERE content LIKE '%e' ESCAPE ?": ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content IN ?': ResolvedType(type: BasicType.text, isArray: true), 'SELECT * FROM demo WHERE content IN ? OR content = ?2': ResolvedType(type: BasicType.text, isArray: true), 'SELECT * FROM demo WHERE content IN (?)': ResolvedType(type: BasicType.text, isArray: false), 'SELECT * FROM demo JOIN tbl ON demo.id = tbl.id WHERE date = ?': ResolvedType(type: BasicType.int, hints: [IsDateTime()]), 'SELECT row_number() OVER (RANGE ? PRECEDING)': ResolvedType(type: BasicType.int), 'SELECT ?;': null, 'SELECT CAST(3 AS TEXT) = ?': ResolvedType(type: BasicType.text), 'SELECT (3 * 4) = ?': ResolvedType(type: BasicType.int), 'SELECT (3 / 4) = ?': ResolvedType(type: BasicType.int), 'SELECT (3 / 4.) = ?': ResolvedType(type: BasicType.real), 'SELECT NULLIF(3, 3) IS ?': ResolvedType(type: BasicType.int, nullable: true), 'SELECT CURRENT_TIMESTAMP = ?': ResolvedType(type: BasicType.text), "SELECT COALESCE(NULL, 'foo') = ?": ResolvedType(type: BasicType.text), 'SELECT NULLIF(3, 4) = ?': ResolvedType(type: BasicType.int, nullable: true), "SELECT 'foo' COLLATE NOCASE = ?": ResolvedType(type: BasicType.text), 'SELECT ? COLLATE BINARY': ResolvedType(type: BasicType.text), "SELECT ('foo' + 'bar') = ?": ResolvedType(type: BasicType.int), 'INSERT INTO demo DEFAULT VALUES ON CONFLICT (id) WHERE ? DO NOTHING': ResolvedType.bool(), 'INSERT INTO demo DEFAULT VALUES ON CONFLICT DO UPDATE SET id = id WHERE ?': ResolvedType.bool(), 'SELECT GROUP_CONCAT(content) = ? FROM demo;': ResolvedType(type: BasicType.text, nullable: true), "SELECT '' -> '' = ?": ResolvedType(type: BasicType.text, nullable: true), "SELECT '' ->> '' = ?": null, "SELECT ? -> 'a' = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT ? ->> 'a' = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT 'a' -> ? = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT 'a' ->> ? = 'b'": ResolvedType(type: BasicType.text, nullable: false), 'SELECT MAX(id, ?) FROM demo': ResolvedType(type: BasicType.int), 'SELECT SUM(id = 2) = ? FROM demo': ResolvedType(type: BasicType.int, nullable: true), "SELECT unixepoch('now') = ?": ResolvedType(type: BasicType.int, nullable: true, hints: [IsDateTime()]), "SELECT datetime('now') = ?": ResolvedType(type: BasicType.text, nullable: true, hints: [IsDateTime()]), 'SELECT CAST(NULLIF(1, 2) AS INTEGER) = ?': ResolvedType( type: BasicType.int, nullable: true, ), "SELECT unhex('ab') = ?": ResolvedType(type: BasicType.blob, nullable: true), 'SELECT unhex(?)': ResolvedType(type: BasicType.text), 'SELECT 1 GROUP BY 1 HAVING ? ': ResolvedType.bool(), "SELECT concat(1, NULL, 2) = ?": ResolvedType(type: BasicType.text, nullable: false), "SELECT concat_ws(',', 1, 2) = ?": ResolvedType(type: BasicType.text, nullable: false), "SELECT concat_ws(NULL, 1, 2) = ?": ResolvedType(type: BasicType.text, nullable: true), }; SqlEngine _spawnEngine() { return SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); } void main() { group('miscellaneous type inference cases', () { _types.forEach((sql, expected) { test('for $sql', () { final engine = _spawnEngine(); final content = engine.analyze(sql); final variable = content.root.allDescendants .firstWhere((node) => node is Variable) as Typeable; expect(content.typeOf(variable).type, equals(expected)); }); }); }); test('resolves all expressions in CTE', () { final engine = _spawnEngine(); final content = engine.analyze(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; '''); final expressions = content.root.allDescendants.whereType(); expect( expressions.map((e) => content.typeOf(e).type), everyElement(isNotNull), ); }); test('concatenation is nullable when any part is', () { // https://github.com/simolus3/drift/issues/1719 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE foobar (foo TEXT, bar TEXT);'); final content = engine.analyze("SELECT foo, bar, foo || ' ' || bar FROM foobar;"); final columns = (content.root as SelectStatement).resolvedColumns!; expect( columns.map(content.typeOf), everyElement(isA() .having((e) => e.type?.nullable, 'type.nullable', isTrue))); }); test('can extract custom type', () { final engine = SqlEngine(); final content = engine.analyze( 'SELECT CAST(1 AS MyCustomType)', stmtOptions: AnalyzeStatementOptions( resolveTypeFromText: expectAsync1( (typeName) { expect(typeName, 'MyCustomType'); return ResolvedType.bool(); }, ), ), ); final select = content.root as SelectStatement; final column = select.resolvedColumns!.single; expect(content.typeOf(column).type, ResolvedType.bool()); }); test('infers json_extract type from context', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_46)) ..registerTableFromSql(''' CREATE TABLE IF NOT EXISTS foo ( bar TEXT NOT NULL, baz INTEGER NOT NULL ); '''); final ctx = engine.analyze(r''' INSERT INTO foo(bar, baz) SELECT json_extract(value, '$.bar'), json_extract(value, '$.baz') FROM json_each(:foo_jsons); '''); final insert = ctx.root as InsertStatement; final select = (insert.source as SelectInsertSource).stmt; expect(ctx.errors, isEmpty); expect(select.resolvedColumns!.map(ctx.types2.typeOf), [ ResolvedType(type: BasicType.text), ResolvedType(type: BasicType.int), ]); }); test('keeps nullability information across unions', () { // https://github.com/simolus3/drift/issues/3351 final engine = SqlEngine(); final ctx = engine.analyze(''' SELECT CAST(NULL AS INT) AS value UNION SELECT CAST(NULL AS INT); '''); final select = ctx.root as CompoundSelectStatement; final column = select.resolvedColumns!.first; expect(ctx.typeOf(column), ResolveResult(ResolvedType(nullable: true, type: BasicType.int))); }); } test/analysis/types2/graph_test.dart 644 0 0 1035 14345646642 15743 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:test/test.dart'; class _FakeTypeable implements Typeable {} void main() { test('copies types for a CopyTypeFrom relation', () { final first = _FakeTypeable(); final second = _FakeTypeable(); final graph = TypeGraph(); graph[first] = const ResolvedType.bool(); graph.addRelation(CopyTypeFrom(second, first)); graph.performResolve(); expect(graph[second], const ResolvedType.bool()); }); } test/analysis/data.dart 644 0 0 2375 14711507160 13262 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; final TableColumn id = TableColumn( 'id', const ResolvedType(type: BasicType.int), definition: ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [PrimaryKeyColumn(null)], ), ); final TableColumn content = TableColumn('content', const ResolvedType(type: BasicType.text)); final Table demoTable = Table( name: 'demo', resolvedColumns: [id, content], ); final TableColumn anotherId = TableColumn('id', const ResolvedType(type: BasicType.int)); final TableColumn dateTime = TableColumn( 'date', const ResolvedType(type: BasicType.int, hints: [IsDateTime()])); final Table anotherTable = Table( name: 'tbl', resolvedColumns: [anotherId, dateTime], ); extension RegisterTableExtension on SqlEngine { /// Utility function that parses a `CREATE TABLE` statement and registers the /// created table to the engine. void registerTableFromSql(String createTable) { final stmt = analyze(createTable).root as TableInducingStatement; registerTable(schemaReader.read(stmt)); } void registerViewFromSql(String createView) { final context = analyze(createView); registerView( schemaReader.readView(context, context.root as CreateViewStatement)); } } test/analysis/regression_test.dart 644 0 0 16150 14612235271 15605 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('regression test for #917', () { // Test for https://github.com/simolus3/drift/issues/917 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE Shops (id INTEGER);') ..registerTableFromSql( 'CREATE TABLE Sales (shop_id INTEGER, date INTEGER, amount REAL);'); final result = engine.analyze(''' SELECT Shops.id, SalesYesterday.amount AS amount_yesterday, SalesToday.amount AS amount_today FROM Sales AS SalesYesterday, ( SELECT SalesToday.amount AS amount, SalesToday.shop_id AS shop_id FROM Sales AS SalesToday LEFT JOIN Shops ON SalesToday.shop_id = Shops.id WHERE SalesToday.date = 8 ) AS SalesToday INNER JOIN Shops ON (SalesYesterday.shop_id = Shops.id) AND (SalesToday.shop_id = Shops.id) WHERE SalesYesterday.date = 9 ORDER BY Shops.id; '''); expect(result.errors, isEmpty); }); test('regression test for #1188', () { // Test for https://github.com/simolus3/drift/issues/1188 final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTableFromSql(''' CREATE TABLE IF NOT EXISTS "employees" ( "id" INTEGER NOT NULL PRIMARY KEY, "name" TEXT NOT NULL UNIQUE, "manager_id" INTEGER ); ''') ..registerTableFromSql(''' CREATE TABLE IF NOT EXISTS "employee_notes" ( "employee_id" INTEGER NOT NULL PRIMARY KEY, "note" TEXT ); '''); final result = engine.analyze(''' WITH RECURSIVE employeeHierarchy(id, name, manager_id) AS ( SELECT id, name, manager_id FROM employees WHERE manager_id IS NULL UNION ALL SELECT e.id, e.name, e.manager_id FROM employees e JOIN employeeHierarchy ON e.manager_id = employeeHierarchy.id ) SELECT e.id, e.name, e.manager_id, n.note FROM employeeHierarchy e LEFT OUTER JOIN employee_notes n ON e.id = n.employee_id ORDER BY e.id; '''); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; expect(columns.map((e) => e.name), ['id', 'name', 'manager_id', 'note']); expect(columns.map((e) => result.typeOf(e).nullable), [false, false, true, true]); }); test('regression test for #1234', () { // https://github.com/simolus3/drift/issues/1234#issuecomment-853270925 final engine = SqlEngine(EngineOptions(driftOptions: const DriftSqlOptions())) ..registerTableFromSql(''' CREATE TABLE inboxes ( id TEXT PRIMARY KEY NOT NULL, group_id TEXT NOT NULL ); ''') ..registerTableFromSql(''' CREATE TABLE assignable_users ( user_id TEXT NOT NULL, inbox_id TEXT NOT NULL ); '''); final result = engine.analyze(''' SELECT * FROM inboxes as i LEFT JOIN assignable_users as au ON au.inbox_id = i.id WHERE group_id = :group_id; '''); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; expect( columns.map((e) => e.name), ['id', 'group_id', 'user_id', 'inbox_id']); expect(columns.map((e) => result.typeOf(e).nullable), [false, false, true, true]); }); test('regression test for #1096', () { // https://github.com/simolus3/drift/issues/1096#issuecomment-931378474 final engine = SqlEngine(EngineOptions( driftOptions: const DriftSqlOptions(), version: SqliteVersion.v3_35)) ..registerTableFromSql(''' CREATE TABLE downloads ( id INT NOT NULL PRIMARY KEY AUTOINCREMENT, uri TEXT NOT NULL, last_modified_time INT, attempts_started_count INT NOT NULL DEFAULT 0, priority INT NOT NULL DEFAULT 0, last_attempt_timestamp INT, status TEXT NOT NULL, handed_off bool NOT NULL DEFAULT false, sync_session INT NOT NULL, UNIQUE (sync_session, uri) ); '''); final result = engine.analyze(''' UPDATE downloads SET status = 'CHECKED_OUT' FROM ( SELECT * FROM downloads ) as w WHERE downloads.id = w.id RETURNING downloads.id; '''); expect(result.errors, isEmpty); final select = result.root as UpdateStatement; final columns = select.returnedResultSet!.resolvedColumns!; expect(columns, hasLength(1)); expect( result.typeOf(columns.single).type, isA() .having((e) => e.type, 'type', BasicType.int) .having((e) => e.nullable, 'nullable', isFalse)); }); test('regression test for #1858', () { // https://github.com/simolus3/drift/issues/1858 final engine = SqlEngine(EngineOptions( driftOptions: const DriftSqlOptions(), version: SqliteVersion.v3_38)); engine.registerTableFromSql(''' CREATE TABLE IF NOT EXISTS contract_has_add_fees ( position_id INTEGER NOT NULL, position_db INTEGER NOT NULL, addfee TEXT NOT NULL, amount REAL NOT NULL, changed DATETIME, removed BOOLEAN NOT NULL DEFAULT FALSE, PRIMARY KEY (position_id, position_db, addfee) ) WITHOUT ROWID; '''); final result = engine.analyze(r''' DELETE FROM contract_has_add_fees WHERE EXISTS(SELECT * FROM json_each(:json) AS j WHERE position_id = json_extract(j.value, '$.positionid') AND position_db = json_extract(j.value, '$.positiondb') AND addfee = json_extract(j.value, '$.addfee') ); '''); expect(result.errors, isEmpty); }); test('regression test for #2010', () { // https://github.com/simolus3/drift/issues/2010 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE place_hierarchy (feature_id INT);') ..registerTableFromSql('CREATE TABLE place_name (feature_id INT);') ..registerTableFromSql('CREATE TABLE place (feature_id INT);'); final result = engine.analyze(''' SELECT ( SELECT true FROM ( SELECT 'test' AS name FROM place_hierarchy ph where ph.feature_id = p.feature_id ) second_select ) first_select FROM place_name matches INNER JOIN place p ON p.feature_id = matches.feature_id; '''); expect(result.errors, isEmpty); }); test('regression test for #2492', () { // https://github.com/simolus3/drift/issues/2492 final engine = SqlEngine() ..registerTableFromSql( 'CREATE TABLE items (id INT NOT NULL PRIMARY KEY)'); final result = engine.analyze(''' WITH filtered_items AS ( SELECT * FROM items -- WHERE ... ) select null as category FROM filtered_items UNION ALL SELECT null as category FROM filtered_items; '''); final select = result.root as BaseSelectStatement; expect(select.resolvedColumns, hasLength(1)); }); } analysis_options.yaml 644 0 0 127 14612235271 13127 0ustar0 pubpubinclude: package:lints/recommended.yaml analyzer: language: strict-casts: true