.gitignore0000644000175000017500000000036613602453413012512 0ustar00pubpub00000000000000# Files and directories created by pub .dart_tool/ .packages # Remove the following pattern if you wish to check in your lock file pubspec.lock # Conventional directory for build outputs build/ # Directory created by dartdoc doc/api/ coverage/CHANGELOG.md0000644000175000017500000000323713611657705012345 0ustar00pubpub00000000000000## 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.LICENSE0000644000175000017500000000205513506466600011531 0ustar00pubpub00000000000000MIT 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. README.md0000644000175000017500000000703013611657705012006 0ustar00pubpub00000000000000# 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: - CRUD: 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 a 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? [Moor](https://pub.dev/packages/moor_flutter), a persistence library for Dart apps, uses this package to generate type-safe methods from sql. ## Limitations Most on this list is just not supported yet because I didn't found a use case for them yet. If you need them, just leave an issue and I'll try to implement them soon. - An `UPSERT` clause is not yet supported on insert statements If you run into parsing errors with what you think is valid sql, please create an issue. ## 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. - To the authors of [SQLDelight](https://github.com/square/sqldelight). This library uses their algorithm for type inference. analysis_options.yaml0000777000175000017500000000000013605060053021466 2../analysis_options.yamlustar00pubpub00000000000000example/sqlparser_example.dart0000644000175000017500000000354313607160456016567 0ustar00pubpub00000000000000import '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() ..registerTable(frameworks) ..registerTable(languages) ..registerTable(frameworkToLanguage); 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'); } } // declare some tables. I know this is verbose and boring, but it's needed so // that the analyzer knows what's going on. final Table frameworks = Table( name: 'frameworks', resolvedColumns: [ TableColumn( 'id', const ResolvedType(type: BasicType.int), ), TableColumn( 'name', const ResolvedType(type: BasicType.text), ), TableColumn( 'popularity', const ResolvedType(type: BasicType.real), ), ], ); final Table languages = Table( name: 'languages', resolvedColumns: [ TableColumn( 'id', const ResolvedType(type: BasicType.int), ), TableColumn( 'name', const ResolvedType(type: BasicType.text), ), ], ); final Table frameworkToLanguage = Table( name: 'uses_language', resolvedColumns: [ TableColumn( 'framework', const ResolvedType(type: BasicType.int), ), TableColumn( 'language', const ResolvedType(type: BasicType.int), ), ], ); lib/sqlparser.dart0000644000175000017500000000073313611657705014170 0ustar00pubpub00000000000000/// An sql parser and analyzer for Dart. library sqlparser; export 'src/analysis/analysis.dart'; export 'src/ast/ast.dart'; export 'src/engine/module/fts5.dart' show Fts5Extension; export 'src/engine/module/module.dart'; export 'src/engine/options.dart'; export 'src/engine/sql_engine.dart'; export 'src/reader/parser/parser.dart' show ParsingError; export 'src/reader/syntactic_entity.dart'; export 'src/reader/tokenizer/token.dart' hide keywords, moorKeywords, isKeyword; lib/src/analysis/analysis.dart0000644000175000017500000000215313611657705016407 0ustar00pubpub00000000000000import 'dart:math' show min, max; 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/engine/options.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/utils/meta.dart'; import 'types2/types.dart'; export 'types2/types.dart' show TypeInferenceResults; part 'context.dart'; part 'error.dart'; part 'schema/column.dart'; part 'schema/from_create_table.dart'; part 'schema/references.dart'; part 'schema/table.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 'steps/type_resolver.dart'; part 'types/data.dart'; part 'types/resolver.dart'; part 'types/typeable.dart'; part 'options.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/context.dart0000644000175000017500000000522613611657705016254 0ustar00pubpub00000000000000part 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; /// Additional information about variables in this context, passed from the /// outside. final AnalyzeStatementOptions stmtOptions; /// Utilities to read types. final SchemaFromCreateTable schemaSupport; /// A resolver that can be used to obtain the type of a [Typeable]. This /// mostly applies to [Expression]s, [Reference]s, [Variable]s and /// [ResultSet.resolvedColumns] of a select statement. /* late final */ TypeResolver types; /// Experimental 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. /// /// This field is null when experimental type inference is disabled. /// /// Please note that types2 is experimental at the moment. Changes to how /// [types] resolves types are considered breaking and are handled /// accordingly. [types2] may change results in any update. @experimental TypeInferenceResults types2; /// Constructs a new analysis context from the AST and the source sql. AnalysisContext(this.root, this.sql, EngineOptions options, {AnalyzeStatementOptions stmtOptions, this.schemaSupport}) : stmtOptions = stmtOptions ?? const AnalyzeStatementOptions() { if (!options.enableExperimentalTypeInference) { types = TypeResolver(this, options); } } /// Reports an analysis error. void reportError(AnalysisError error) { errors.add(error); } /// Obtains the result of any typeable component. See the information at /// [types] on important [Typeable]s. ResolveResult typeOf(Typeable t) { if (types2 != null) { final type = types2.typeOf(t); return type != null ? ResolveResult(type) : const ResolveResult.unknown(); } return types.resolveOrInfer(t); } /// 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.dart0000644000175000017500000000317513602453413015710 0ustar00pubpub00000000000000part of 'analysis.dart'; class AnalysisError { final AstNode relevantNode; final String message; final AnalysisErrorType type; AnalysisError({@required this.type, this.message, this.relevantNode}); /// 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 be null. FileSpan get span { final first = relevantNode?.first?.span; final last = relevantNode?.last?.span; if (first != null && last != null) { return first.expand(last); } return null; } @override String toString() { final msgSpan = span; if (msgSpan != null) { return msgSpan.message(message ?? type.toString(), color: true); } else { return 'Error: $type: $message at $relevantNode'; } } } 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 AnalysisErrorType type, this.reference, this.available, AstNode relevantNode}) : super(type: type, relevantNode: relevantNode); @override String get message { return 'Could not find $reference. Available are: ${available.join(', ')}'; } } enum AnalysisErrorType { referencedUnknownTable, referencedUnknownColumn, ambiguousReference, /// Note that most syntax errors are reported as [ParsingError] synctactic, unknownFunction, compoundColumnCountMismatch, cteColumnCountMismatch, other, } lib/src/analysis/options.dart0000644000175000017500000000163113611657705016257 0ustar00pubpub00000000000000part of 'analysis.dart'; /// 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; const AnalyzeStatementOptions({ this.indexedVariableTypes = const {}, this.namedVariableTypes = const {}, }); /// 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! if (variable.resolvedIndex != null && indexedVariableTypes.containsKey(variable.resolvedIndex)) { return indexedVariableTypes[variable.resolvedIndex]; } else if (variable is ColonNamedVariable) { return namedVariableTypes[variable.name]; } return null; } } lib/src/analysis/schema/column.dart0000644000175000017500000001241413607160456017317 0ustar00pubpub00000000000000part 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; Column(); @override String humanReadableDescription() { return name; } } /// A column that is part of a table. class TableColumn extends Column { @override final String name; /// The type of this column, which is available before any resolution happens /// (we know if from the table). final 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; TableColumn(this.name, this.type, {this.definition}); /// 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() { 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.indexedColumns; if (columns.length == 1 && columns.single.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()}'; } } /// 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; ExpressionColumn({@required this.name, this.expression}); } /// 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 => overriddenName ?? reference.resolvedColumn?.name; final String overriddenName; ReferenceExpressionColumn(Reference ref, {this.overriddenName}) : super(name: null, expression: ref); } /// A column that wraps another column. mixin DelegatedColumn on Column { Column get innerColumn; @override String get name => innerColumn.name; } /// 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); } lib/src/analysis/schema/from_create_table.dart0000644000175000017500000000535713607160456021467 0ustar00pubpub00000000000000part 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 moorExtensions; SchemaFromCreateTable({this.moorExtensions = false}); Table read(TableInducingStatement stmt) { if (stmt is CreateTableStatement) { return _readCreateTable(stmt); } else if (stmt is CreateVirtualTableStatement) { final module = stmt.scope.resolve(stmt.moduleName); return module.parseTable(stmt); } throw AssertionError('Unknown table statement'); } Table _readCreateTable(CreateTableStatement stmt) { return Table( name: stmt.tableName, resolvedColumns: [for (var def in stmt.columns) _readColumn(def)], withoutRowId: stmt.withoutRowId, tableConstraints: stmt.tableConstraints, definition: stmt, ); } TableColumn _readColumn(ColumnDefinition definition) { final typeName = definition.typeName.toUpperCase(); final type = resolveColumnType(typeName); final nullable = !definition.constraints.any((c) => c is NotNull); final resolvedType = type.withNullable(nullable); return TableColumn( definition.columnName, resolvedType, definition: definition, ); } /// Resolves a column type via its typename, see the linked rules below. /// Additionally, if [moorExtensions] 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) { if (typeName == null) { return const ResolvedType(type: BasicType.blob); } final upper = typeName.toUpperCase(); if (upper.contains('INT')) { 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 (moorExtensions) { if (upper.contains('BOOL')) { return const ResolvedType.bool(); } if (upper.contains('DATE')) { return const ResolvedType(type: BasicType.int, hint: IsDateTime()); } } return const ResolvedType(type: BasicType.real); } /// 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; } lib/src/analysis/schema/references.dart0000644000175000017500000000657513607160456020156 0ustar00pubpub00000000000000part 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 {} /// A referencable which is still visible in child scopes. This doesn't apply to /// many things, basically only 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. mixin VisibleToChildren on Referencable {} /// Class which keeps track of references for tables, columns and functions in a /// query. class ReferenceScope { final ReferenceScope parent; final ReferenceScope root; /// Gets the effective root scope. If no [root] scope has been set, this /// scope is assumed to be the root scope. ReferenceScope get effectiveRoot => root ?? this; final Map> _references = {}; /// All columns that would be available in this scope. Can be used to resolve /// a '*' expression for function calls or result columns List availableColumns; ReferenceScope(this.parent, {this.root}); ReferenceScope createChild() { // wonder why we're creating a linked list of reference scopes instead of // just passing down a copy of [_references]? In sql, some variables can be // used before they're defined, even in child scopes: // SELECT *, (SELECT * FROM table2 WHERE id = t1.a) FROM table2 t1 return ReferenceScope(this, root: effectiveRoot); } ReferenceScope createSibling() { return parent.createChild(); } /// Registers something that can be referenced in this and child scopes. void register(String identifier, Referencable ref) { _references.putIfAbsent(identifier.toUpperCase(), () => []).add(ref); } /// Resolves to a [Referencable] with the given [name] and of the type [T]. /// If the reference couldn't be found, null is returned and [orElse] will be /// called. T resolve(String name, {Function() orElse}) { var scope = this; var isAtParent = false; final upper = name.toUpperCase(); while (scope != null) { if (scope._references.containsKey(upper)) { final candidates = scope._references[upper]; final resolved = candidates.whereType().where((x) { return x is VisibleToChildren || !isAtParent; }); if (resolved.isNotEmpty) { return resolved.first; } } scope = scope.parent; isAtParent = true; } if (orElse != null) orElse(); return null; // not found in any parent scope } /// Returns everything that is in scope and a subtype of [T]. List allOf() { var scope = this; var isInCurrentScope = true; final collected = []; while (scope != null) { var foundValues = scope._references.values.expand((list) => list).whereType(); if (!isInCurrentScope) { foundValues = foundValues.whereType().cast(); } collected.addAll(foundValues); scope = scope.parent; isInCurrentScope = false; } return collected; } } lib/src/analysis/schema/table.dart0000644000175000017500000000546013611657705017117 0ustar00pubpub00000000000000part 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_']; /// 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 class ResultSet implements ResolvesToResultSet { /// The columns that will be returned when evaluating this query. List get resolvedColumns; @override ResultSet get resultSet => this; Column findColumn(String name) { return resolvedColumns.firstWhere((c) => c.name == name, orElse: () => null); } } /// A database table. The information stored here will be used to resolve /// references and for type inference. class Table with ResultSet, VisibleToChildren, 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]. final String 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; } @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; /// Additional constraints set on this table. final List tableConstraints; /// The ast node that created this table final TableInducingStatement definition; TableColumn _rowIdColumn; /// Constructs a table from the known [name] and [resolvedColumns]. Table( {@required this.name, this.resolvedColumns, this.withoutRowId = false, this.tableConstraints = const [], this.definition}) { for (final column in resolvedColumns) { column.table = this; if (_rowIdColumn == null && column.isAliasForRowId()) { _rowIdColumn = column; } } } @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; } } lib/src/analysis/steps/column_resolver.dart0000644000175000017500000001712113611657705021141 0ustar00pubpub00000000000000part 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, void arg) { // visit children first so that common table expressions are resolved visitChildren(e, arg); _resolveSelect(e); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { // first, visit all children so that the compound parts have their columns // resolved visitChildren(e, arg); final columnSets = [ e.base.resolvedColumns, for (var part in e.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: e, 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)); } e.resolvedColumns = resolved; } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { visitChildren(e, arg); final resolved = e.as.resolvedColumns; final names = e.columnNames; if (names != null && resolved != null && 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, )); } } @override void visitUpdateStatement(UpdateStatement e, void arg) { final table = _resolveTableReference(e.table); e.scope.availableColumns = table.resolvedColumns; visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { final table = _resolveTableReference(e.table); visitChildren(e, arg); e.scope.availableColumns = table.resolvedColumns; visitChildren(e, arg); } @override void visitDeleteStatement(DeleteStatement e, void arg) { final table = _resolveTableReference(e.from); e.scope.availableColumns = table.resolvedColumns; visitChildren(e, arg); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final table = _resolveTableReference(e.onTable); if (table == null) { // further analysis is not really possible without knowing the table super.visitCreateTriggerStatement(e, arg); return; } final scope = e.scope; if (e.target.introducesNew) { scope.register('new', table); } if (e.target.introducesOld) { scope.register('old', table); } visitChildren(e, arg); } void _handle(Queryable queryable, List availableColumns) { queryable.when( isTable: (table) { final resolved = _resolveTableReference(table); if (resolved != null) { // an error will be logged when resolved is null, so the != null check // is fine and avoids crashes availableColumns.addAll(table.resultSet.resolvedColumns); } }, isSelect: (select) { // the inner select statement doesn't have access to columns defined in // the outer statements, which is why we use _resolveSelect instead of // passing availableColumns down to a recursive call of _handle _resolveSelect(select.statement); availableColumns.addAll(select.statement.resolvedColumns); }, isJoin: (join) { _handle(join.primary, availableColumns); for (final query in join.joins.map((j) => j.query)) { _handle(query, availableColumns); } }, ); } void _resolveSelect(SelectStatement s) { final availableColumns = []; for (final queryable in s.from) { _handle(queryable, availableColumns); } final usedColumns = []; final scope = s.scope; // 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 s.columns) { if (resultColumn is StarResultColumn) { Iterable visibleColumnsForStar; if (resultColumn.tableName != null) { final tableResolver = scope .resolve(resultColumn.tableName, orElse: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); }); visibleColumnsForStar = tableResolver.resultSet.resolvedColumns; } else { // we have a * column without a table, that resolves to every columns // available visibleColumnsForStar = availableColumns; } usedColumns .addAll(visibleColumnsForStar.where((e) => e.includedInResults)); } else if (resultColumn is ExpressionResultColumn) { final expression = resultColumn.expression; Column column; if (expression is Reference) { column = ReferenceExpressionColumn(expression, overriddenName: resultColumn.as); } else { final name = _nameOfResultColumn(resultColumn); column = ExpressionColumn(name: name, expression: resultColumn.expression); } usedColumns.add(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); } } } } s.resolvedColumns = usedColumns; scope.availableColumns = availableColumns; } 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) { final scope = r.scope; final resolvedTable = scope.resolve(r.tableName, orElse: () { final available = scope.allOf().map((t) => t.name); context.reportError(UnresolvedReferenceError( type: AnalysisErrorType.referencedUnknownTable, relevantNode: r, reference: r.tableName, available: available, )); }); return r.resolved = resolvedTable; } } lib/src/analysis/steps/linting_visitor.dart0000644000175000017500000000111413611657705021141 0ustar00pubpub00000000000000part 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; LintingVisitor(this.options, this.context); @override void visitInvocation(SqlInvocation e, void arg) { final lowercaseCall = e.name.toLowerCase(); if (options.addedFunctions.containsKey(lowercaseCall)) { options.addedFunctions[lowercaseCall].reportErrors(e, context); } visitChildren(e, arg); } } lib/src/analysis/steps/prepare_ast.dart0000644000175000017500000001434513611657705020235 0ustar00pubpub00000000000000part 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({this.context}); void start(AstNode root) { root.accept(this, null); _resolveIndexOfVariables(); } @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; final scope = e.scope; if (isInFROM) { final surroundingSelect = e.parents.firstWhere((node) => node is BaseSelectStatement).scope; final forked = surroundingSelect.createSibling(); e.scope = forked; } else { final forked = scope.createChild(); e.scope = forked; } for (final windowDecl in e.windowDeclarations) { e.scope.register(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 visitResultColumn(ResultColumn e, void arg) { if (e is StarResultColumn) { // doesn't need special treatment, star expressions can't be referenced } else if (e is ExpressionResultColumn) { if (e.as != null) { e.scope.register(e.as, e); } } visitChildren(e, arg); } @override void visitQueryable(Queryable e, void arg) { final scope = e.scope; e.when( isTable: (table) { // we're looking at something like FROM table (AS alias). The alias // acts like a table for expressions in the same scope, so let's // register it. if (table.as != null) { scope.register(table.as, table); } }, isSelect: (select) { if (select.as != null) { scope.register(select.as, select.statement); } }, isJoin: (join) { // the join can contain multiple tables. Luckily for us, all of them are // Queryables, so we can deal with them by visiting the children and // dont't need to do anything here. }, ); visitChildren(e, arg); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { e.scope.register(e.cteTableName, e); 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); } void _resolveIndexOfVariables() { // sort variables by the order in which they appear inside the statement. _foundVariables.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 _foundVariables) { 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) { variable.resolvedIndex = variable.explicitIndex; largestAssigned = max(largestAssigned, variable.resolvedIndex); } 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; } } } void _forkScope(AstNode node) { node.scope = node.scope.createChild(); } @override void visitChildren(AstNode e, void arg) { // hack to fork scopes on statements (selects are handled above) if (e is Statement && e is! SelectStatement) { _forkScope(e); } super.visitChildren(e, arg); } } lib/src/analysis/steps/reference_resolver.dart0000644000175000017500000000665513611657705021614 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Resolves any open [Reference] it finds in the AST. class ReferenceResolver extends RecursiveVisitor { final AnalysisContext context; ReferenceResolver(this.context); @override void visitReference(Reference e, void arg) { if (e.resolved != null) { return super.visitReference(e, arg); } final scope = e.scope; if (e.tableName != null) { // first find the referenced table, then use the column on that table. final tableResolver = scope.resolve(e.tableName); final resultSet = tableResolver?.resultSet; if (resultSet == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${e.tableName}', relevantNode: e, )); } else { final column = resultSet.findColumn(e.columnName); if (column == null) { _reportUnknownColumnError(e, columns: resultSet.resolvedColumns); } else { e.resolved = column; } } } 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 columns = scope.availableColumns.where((c) => c?.name == e.columnName).toSet(); if (columns.isEmpty) { _reportUnknownColumnError(e); } else { if (columns.length > 1) { final description = columns.map((c) => c.humanReadableDescription()).join(', '); context.reportError(AnalysisError( type: AnalysisErrorType.ambiguousReference, relevantNode: e, message: 'Could refer to any of: $description', )); } e.resolved = columns.first; } } visitChildren(e, arg); } void _reportUnknownColumnError(Reference e, {Iterable columns}) { columns ??= e.scope.availableColumns; final columnNames = e.scope.availableColumns .map((c) => c.humanReadableDescription()) .join(', '); context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownColumn, relevantNode: e, message: 'Unknown column. These columns are available: $columnNames', )); } Column _resolveRowIdAlias(Reference e) { // to resolve those aliases when they're not bound to a table, the // surrounding select statement may only read from one table final select = e.parents.firstWhere((node) => node is SelectStatement, orElse: () => null) as SelectStatement; if (select == null) return null; if (select.from.length != 1 || select.from.single is! TableReference) { return null; } final table = (select.from.single as TableReference).resolved as Table; if (table == null) return null; // table.findColumn contains logic to resolve row id aliases return table.findColumn(e.columnName); } @override void visitAggregateExpression(AggregateExpression e, void arg) { if (e.windowName != null && e.resolved == null) { final resolved = e.scope.resolve(e.windowName); e.resolved = resolved; } visitChildren(e, arg); } } lib/src/analysis/steps/set_parent_visitor.dart0000644000175000017500000000065613607160456021650 0ustar00pubpub00000000000000part 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) { assert(child != null, '$node had a null-child'); _applyFor(child, node); } } } lib/src/analysis/steps/type_resolver.dart0000644000175000017500000000344313611657705020627 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Resolves types for all nodes in the AST which can have a type. This includes /// expressions, variables and so on. For select statements, we also try to /// figure out what types they return. class TypeResolvingVisitor extends RecursiveVisitor { final AnalysisContext context; TypeResolver get types => context.types; TypeResolvingVisitor(this.context); @override void visitChildren(AstNode e, void arg) { // called for every ast node, so we implement this here if (e is Expression && !types.needsToBeInferred(e)) { types.resolveExpression(e); } else if (e is SelectStatement) { e.resolvedColumns.forEach(types.resolveColumn); } super.visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { // resolve target columns - this is easy, as we should have the table // structure available. e.targetColumns.forEach(types.resolveExpression); // if the insert statement has a VALUES source, we can now infer the type // for those expressions by comparing with the target column. if (e.source is ValuesSource) { final targetTypes = e.resolvedTargetColumns.map(context.typeOf).toList(); final source = e.source as ValuesSource; for (final tuple in source.values) { final expressions = tuple.expressions; for (var i = 0; i < min(expressions.length, targetTypes.length); i++) { if (i < targetTypes.length) { context.types.markResult(expressions[i], targetTypes[i]); } } } // we already handled the source tuples, don't visit them visit(e.table, arg); for (final column in e.targetColumns) { visit(column, arg); } } else { visitChildren(e, arg); } } } lib/src/analysis/types/data.dart0000644000175000017500000000441513611657705016644 0ustar00pubpub00000000000000part of '../analysis.dart'; /// A type that sql expressions can have at runtime. enum BasicType { nullType, int, real, text, blob, } class ResolvedType { 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 TypeHint hint; /// 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.hint, this.nullable = false, this.isArray = false}); const ResolvedType.bool({bool nullable}) : this(type: BasicType.int, hint: const IsBoolean(), nullable: nullable); ResolvedType withNullable(bool nullable) { return ResolvedType( type: type, hint: hint, nullable: nullable, isArray: isArray); } ResolvedType toArray(bool array) { return ResolvedType( type: type, hint: hint, nullable: nullable, isArray: array); } @override bool operator ==(dynamic other) { return identical(this, other) || other is ResolvedType && other.type == type && other.hint == hint && other.nullable == nullable && other.isArray == isArray; } @override int get hashCode { return type.hashCode + hint.hashCode + nullable.hashCode; } @override String toString() { return 'ResolvedType($type, hint: $hint, 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 ==(dynamic 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(); } lib/src/analysis/types/resolver.dart0000644000175000017500000004201613611657705017573 0ustar00pubpub00000000000000part of '../analysis.dart'; const _comparisonOperators = [ TokenType.equal, TokenType.doubleEqual, TokenType.exclamationEqual, TokenType.lessMore, TokenType.and, TokenType.or, TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, ]; class TypeResolver { final Map _results = {}; final AnalysisContext context; final EngineOptions options; TypeResolver(this.context, this.options); ResolveResult _cache( ResolveResult Function(T param) resolver, T typeable) { if (_results.containsKey(typeable)) { return _results[typeable]; } final calculated = resolver(typeable); if (calculated.type != null) { _results[typeable] = calculated; } return calculated; } /// Manually writes the [result] for the [Typeable] [t]. void markResult(Typeable t, ResolveResult result) { _results.putIfAbsent(t, () => result); } bool _canResolve(Typeable t) { if (t is Column) return true; // neither a column nor an expression. Can't resolve that if (t is! Expression) return false; final expr = t as Expression; // if this expression contains a variable we didn't resolve yet, we can't // be sure that we can resolve the entire expression. final containsVariable = expr.selfAndDescendants.any((node) => (node is Variable || node is DartExpressionPlaceholder) && !_results.containsKey(node)); return !containsVariable; } bool needsToBeInferred(Typeable t) { return t is Variable || t is DartExpressionPlaceholder; } ResolveResult resolveOrInfer(Typeable t) { if (t is Column) { return resolveColumn(t); } else if (needsToBeInferred(t)) { return inferType(t as Expression); } else if (t is Expression) { return resolveExpression(t); } throw StateError('Unknown typeable $t'); } ResolveResult justResolve(Typeable t) { if (t is Column) { return resolveColumn(t); } else if (t is Expression) { return resolveExpression(t); } throw StateError('Unknown typeable $t'); } ResolveResult resolveColumn(Column column) { return _cache((column) { if (column is TableColumn) { // todo probably needs to be nullable when coming from a join? return ResolveResult(column.type); } else if (column is ExpressionColumn) { return resolveOrInfer(column.expression); } else if (column is DelegatedColumn) { return resolveColumn(column.innerColumn); } throw StateError('Unknown column $column'); }, column); } ResolveResult resolveExpression(Expression expr) { return _cache((expr) { if (expr is Literal) { return resolveLiteral(expr); } else if (expr is UnaryExpression) { return resolveExpression(expr.inner); } else if (expr is Parentheses) { return resolveExpression(expr.expression); } else if (expr is Variable || expr is Tuple) { // todo we can probably resolve tuples by looking at their content return const ResolveResult.needsContext(); } else if (expr is Reference) { final resolved = expr.resolved; if (resolved != null) { return resolveColumn(expr.resolved as Column); } else { return const ResolveResult.unknown(); } } else if (expr is SqlInvocation) { return resolveFunctionCall(expr); } else if (expr is IsExpression || expr is IsNullExpression || expr is InExpression || expr is StringComparisonExpression || expr is BetweenExpression || expr is ExistsExpression) { return const ResolveResult(ResolvedType.bool()); } else if (expr is BinaryExpression) { final operator = expr.operator.type; if (_comparisonOperators.contains(operator)) { return const ResolveResult(ResolvedType.bool()); } else { return _encapsulate(expr.childNodes.cast(), [BasicType.int, BasicType.real, BasicType.text, BasicType.blob]); } } else if (expr is CaseExpression) { return resolveExpression(expr.whens.first.then); } else if (expr is CastExpression) { final type = context.schemaSupport.resolveColumnType(expr.typeName); return ResolveResult(type); } else if (expr is SubQuery) { final columns = expr.select.resultSet.resolvedColumns; if (columns.length != 1) { // select queries _must_ have exactly one column return const ResolveResult.unknown(); } else { return justResolve(columns.single); } } return const ResolveResult.unknown(); }, expr); } ResolveResult resolveLiteral(Literal l) { return _cache((l) { if (l is StringLiteral) { return ResolveResult( ResolvedType(type: l.isBinary ? BasicType.blob : BasicType.text)); } else if (l is BooleanLiteral) { return const ResolveResult(ResolvedType.bool()); } else if (l is NumericLiteral) { return ResolveResult( ResolvedType(type: l.isInt ? BasicType.int : BasicType.real)); } else if (l is NullLiteral) { return const ResolveResult( ResolvedType(type: BasicType.nullType, nullable: true)); } throw StateError('Unknown literal $l'); }, l); } ResolveResult resolveFunctionCall(SqlInvocation call) { return _cache((SqlInvocation call) { final parameters = call.expandParameters(); final firstNullable = // ignore: avoid_bool_literals_in_conditional_expressions parameters.isEmpty ? false : justResolve(parameters.first).nullable; final anyNullable = parameters.map(justResolve).any((r) => r.nullable); final lowercaseName = call.name.toLowerCase(); switch (lowercaseName) { case 'round': // if there is only one param, returns an int. otherwise real if (parameters.length == 1) { return ResolveResult( ResolvedType(type: BasicType.int, nullable: firstNullable)); } else { return ResolveResult( ResolvedType(type: BasicType.real, nullable: anyNullable)); } break; case 'sum': final firstType = justResolve(parameters.first); if (firstType.type?.type == BasicType.int) { return firstType; } else { return ResolveResult(ResolvedType( type: BasicType.real, nullable: firstType.nullable)); } break; // can't happen, though case 'lower': case 'ltrim': case 'printf': case 'replace': case 'rtrim': case 'substr': case 'trim': case 'upper': case 'group_concat': return ResolveResult( ResolvedType(type: BasicType.text, nullable: firstNullable)); case 'date': case 'time': case 'datetime': case 'julianday': case 'strftime': case 'char': case 'hex': case 'quote': case 'soundex': case 'sqlite_compileoption_set': case 'sqlite_version': case 'typeof': return const ResolveResult(ResolvedType(type: BasicType.text)); 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': return const ResolveResult(ResolvedType(type: BasicType.int)); case 'instr': case 'length': case 'unicode': return ResolveResult( ResolvedType(type: BasicType.int, nullable: anyNullable)); case 'randomblob': case 'zeroblob': return const ResolveResult(ResolvedType(type: BasicType.blob)); case 'total': case 'avg': case 'percent_rank': case 'cume_dist': return const ResolveResult(ResolvedType(type: BasicType.real)); case 'abs': case 'likelihood': case 'likely': case 'unlikely': return justResolve(parameters.first); case 'coalesce': case 'ifnull': return _encapsulate(parameters, [BasicType.int, BasicType.real, BasicType.text, BasicType.blob]); case 'nullif': return justResolve(parameters.first).withNullable(true); case 'first_value': case 'last_value': case 'lag': case 'lead': case 'nth_value': return justResolve(parameters.first); case 'max': return _encapsulate(parameters, [ BasicType.int, BasicType.real, BasicType.text, BasicType.blob ]).withNullable(true); case 'min': return _encapsulate(parameters, [ BasicType.blob, BasicType.text, BasicType.int, BasicType.real ]).withNullable(true); } if (options.enableJson1) { switch (call.name.toLowerCase()) { case 'json': case 'json_array': case 'json_insert': case 'json_replace': case 'json_set': case 'json_object': case 'json_patch': case 'json_remove': case 'json_quote': case 'json_group_array': case 'json_group_object': return const ResolveResult(ResolvedType(type: BasicType.text)); case 'json_type': return const ResolveResult( ResolvedType(type: BasicType.text, nullable: true)); case 'json_valid': return const ResolveResult(ResolvedType.bool()); case 'json_extract': // return unknown so that we don't hide the state error. In reality // we have no idea what json_extract returns return const ResolveResult.unknown(); case 'json_array_length': return const ResolveResult(ResolvedType(type: BasicType.int)); } } if (options.addedFunctions.containsKey(lowercaseName)) { return options.addedFunctions[lowercaseName] .inferReturnType(context, call, parameters); } throw StateError('Unknown function: ${call.name}'); }, call); } ResolveResult _resolveFunctionArgument( SqlInvocation parent, Expression argument) { return _cache((argument) { final functionName = parent.name.toLowerCase(); final args = parent.expandParameters(); // the second argument of nth_value is always an integer if (functionName == 'nth_value' && args.length > 1 && argument == args[1]) { return const ResolveResult(ResolvedType(type: BasicType.int)); } if (options.addedFunctions.containsKey(functionName)) { return options.addedFunctions[functionName] .inferArgumentType(context, parent, argument); } return const ResolveResult.unknown(); }, argument); } ResolveResult inferType(Expression e) { return _cache((e) { var parent = e.parent; if (e is Variable) { final specifiedType = context.stmtOptions.specifiedTypeOf(e); if (specifiedType != null) { return ResolveResult(specifiedType); } } if (parent is FunctionParameters) { // analyze the function, the parameters are meaningless parent = parent.parent; } if (parent is Expression) { final result = _argumentType(parent, e); // while more context is needed, look at the parent final inferredType = result.needsContext ? inferType(parent) : result; // If this appears in a tuple, e.g. test IN (?). The "(?)" will be an // array. Of course, the individual entry is not, so reset that state. if (parent is Tuple) { return inferredType.mapResult((r) => r.toArray(false)); } return inferredType; } else if (parent is Limit) { return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (parent is SetComponent) { return resolveColumn(parent.column.resolved as Column); } else if (parent is FrameSpec) { // appears as part of a bounded window definition: // RANGE BETWEEN PRECEDING AND FOLLOWING return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (parent is HasWhereClause && e == parent.where) { return const ResolveResult(ResolvedType.bool()); } return const ResolveResult.unknown(); }, e); } ResolveResult _argumentType(Expression parent, Expression argument) { if (parent is IsExpression || parent is InExpression || parent is BinaryExpression || parent is BetweenExpression || parent is CaseExpression) { final relevant = parent.childNodes.lastWhere((node) { return node != argument && node is Typeable && _canResolve(node as Typeable); }, orElse: () => null); if (relevant == null) { return const ResolveResult.unknown(); } final resolved = justResolve(relevant as Typeable); // if we have "a x IN argument" expression, the argument will be an array if (parent is InExpression && argument == parent.inside) { return resolved.mapResult((r) => r.toArray(true)); } return resolved; } else if (parent is StringComparisonExpression) { if (argument == parent.escape) { return const ResolveResult(ResolvedType(type: BasicType.text)); } else { final otherNode = parent.childNodes .firstWhere((node) => node is Expression && node != argument); return resolveExpression(otherNode as Expression); } } else if (parent is Parentheses || parent is Tuple || parent is UnaryExpression) { return const ResolveResult.needsContext(); } else if (parent is SqlInvocation) { // if we have a special case for the mix of function and argument, use // that. Otherwise, just assume that the argument has the same type as the // return type of the function final directlyResolved = _resolveFunctionArgument(parent, argument); if (!directlyResolved.unknown) { return directlyResolved; } return resolveFunctionCall(parent); } throw StateError('Cannot infer argument type: $parent'); } /// Returns the type of an expression in [expressions] that has the highest /// order in [types]. ResolveResult _encapsulate( Iterable expressions, List types) { final argTypes = expressions .map((expr) => justResolve(expr).type) .where((t) => t != null); final type = types.lastWhere((t) => argTypes.any((arg) => arg.type == t), orElse: () => null); if (type == null) return const ResolveResult.unknown(); final notNull = argTypes.any((t) => !t.nullable); return ResolveResult(ResolvedType(type: type, nullable: !notNull)); } } /// 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 != null) { 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 ==(dynamic 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/typeable.dart0000644000175000017500000000012713506466600017527 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Something that has a type. abstract class Typeable {} lib/src/analysis/types2/expectation.dart0000644000175000017500000000447713611657705020350 0ustar00pubpub00000000000000part 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(); } /// 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; 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); bool accepts(ResolvedType type) { final baseType = type.type; switch (_type) { case _RoughType.numeric: return baseType == BasicType.int || baseType == BasicType.real; } return false; } ResolvedType defaultType() { switch (_type) { case _RoughType.numeric: return const ResolvedType(type: BasicType.real); } throw AssertionError(); } } 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); } lib/src/analysis/types2/graph/relationships.dart0000644000175000017500000000416013611657705021777 0ustar00pubpub00000000000000part 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; CopyTypeFrom(this.target, this.other, {this.array}); } /// 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; CopyEncapsulating(this.target, this.from); } /// Dependency declaring that [first] and [second] have the same type. This is /// an optional dependency that will only be applied when one type is known and /// the other is not. class HaveSameType extends TypeRelation { final Typeable first; final Typeable second; HaveSameType(this.first, this.second); Typeable getOther(Typeable t) { assert(t == first || t == second); return t == first ? second : first; } } /// 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; DefaultType(this.target, this.defaultType); } enum CastMode { numeric, boolean } /// 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; CopyAndCast(this.target, this.other, this.cast); } lib/src/analysis/types2/graph/type_graph.dart0000644000175000017500000001377413611657705021270 0ustar00pubpub00000000000000part of '../types.dart'; class TypeGraph { final _ResolvedVariables variables = _ResolvedVariables(); final Map _knownTypes = {}; final Map _knownNullability = {}; final List _relations = []; final Map> _edges = {}; final Set _multiSources = {}; final List _defaultTypes = []; TypeGraph(); ResolvedType operator [](Typeable t) { final normalized = variables.normalize(t); if (_knownTypes.containsKey(normalized)) { return _knownTypes[normalized]; } return null; } void operator []=(Typeable t, ResolvedType type) { final normalized = variables.normalize(t); _knownTypes[normalized] = type; if (type.nullable != null) { // nullability is known _knownNullability[normalized] = type.nullable; } } bool knowsType(Typeable t) => _knownTypes.containsKey(variables.normalize(t)); void addRelation(TypeRelation relation) { _relations.add(relation); } void performResolve() { _indexRelations(); final queue = List.of(_knownTypes.keys); while (queue.isNotEmpty) { _propagateTypeInfo(queue, queue.removeLast()); } // propagate many-to-one sources where we don't know each source type for (final remaining in _multiSources) { _propagateManyToOne(remaining, queue); } // apply default types for (final applyDefault in _defaultTypes) { if (!knowsType(applyDefault.target)) { this[applyDefault.target] = applyDefault.defaultType; } } } void _propagateTypeInfo(List resolved, Typeable t) { 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); } _copyType(resolved, edge.other, edge.target, type); } else if (edge is HaveSameType) { _copyType(resolved, t, edge.getOther(t)); } else if (edge is CopyAndCast) { _copyType(resolved, t, edge.target, this[t].cast(edge.cast)); } else if (edge is MultiSourceRelation) { // handle many-to-one changes, if all targets have been resolved if (edge.from.every(knowsType)) { _multiSources.remove(edge); _propagateManyToOne(edge, resolved); } } } } void _propagateManyToOne(MultiSourceRelation edge, List resolved) { if (!knowsType(edge.target)) { final fromTypes = edge.from.map((t) => this[t]).where((e) => e != null); final encapsulated = _encapsulate(fromTypes); if (encapsulated != null) { this[edge.target] = encapsulated; 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) { return targets.fold(null, (previous, element) { return previous?.union(element) ?? element; }); } void _indexRelations() { _edges.clear(); void put(Typeable t, TypeRelation r) { _edges.putIfAbsent(t, () => []).add(r); } void putAll(MultiSourceRelation r) { _multiSources.add(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) { put(relation.first, relation); put(relation.second, 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 as Variable; return _referenceForIndex[normalized.resolvedIndex] ??= normalized; } } extension on ResolvedType { ResolvedType union(ResolvedType other) { if (other == this) return this; if (other.type == type) { final thisNullable = nullable ?? true; final otherNullable = other.nullable ?? true; return withNullable(thisNullable || otherNullable); } // fallback. todo: Support more cases return const ResolvedType(type: BasicType.text, nullable: true); } ResolvedType cast(CastMode mode) { switch (mode) { case CastMode.numeric: if (type == BasicType.int || type == BasicType.real) return this; return const ResolvedType(type: BasicType.real); case CastMode.boolean: return const ResolvedType.bool(); } throw AssertionError('all switch statements handled'); } } lib/src/analysis/types2/resolving_visitor.dart0000644000175000017500000004550313611657705021607 0ustar00pubpub00000000000000part of 'types.dart'; const _intType = ResolvedType(type: BasicType.int); const _realType = ResolvedType(type: BasicType.real); const _textType = ResolvedType(type: BasicType.text); const _expectInt = ExactTypeExpectation.laxly(_intType); const _expectNum = RoughTypeExpectation.numeric(); const _expectString = ExactTypeExpectation.laxly(_textType); class TypeResolver extends RecursiveVisitor { final TypeInferenceSession session; 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); var currentColumnIndex = 0; final columnExpectations = arg is SelectTypeExpectation ? arg.columnExpectations : const []; for (final child in e.childNodes) { if (child == e.where) continue; // handled above 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.availableColumns.length; } } else { visit(child, 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 []; targets.forEach(_handleColumn); final expectations = targets.map((r) { if (session.graph.knowsType(r)) { return ExactTypeExpectation(session.typeOf(r)); } return const NoTypeExpectation(); }).toList(); e.source.when( isSelect: (select) { visit(select.stmt, SelectTypeExpectation(expectations)); }, isValues: (values) { // todo: It would be nice to remove this special case. Can we generalize // the SelectTypeExpectation so that it works for tuples and just visit // e.source? for (final tuple in values.values) { for (var i = 0; i < tuple.expressions.length; i++) { final expectation = i < expectations.length ? expectations[i] : const NoTypeExpectation(); visit(tuple.expressions[i], expectation); } } }, ); } @override void visitCrudStatement(CrudStatement stmt, TypeExpectation arg) { if (stmt is HasWhereClause) { final typedStmt = stmt as HasWhereClause; _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 visitSetComponent(SetComponent e, TypeExpectation arg) { visit(e.column, const NoTypeExpectation()); _lazyCopy(e.expression, e.column); visit(e.expression, const NoTypeExpectation()); } @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 visitLiteral(Literal e, TypeExpectation arg) { ResolvedType type; if (e is NullLiteral) { type = const ResolvedType(type: BasicType.nullType, nullable: true); session._hintNullability(e, true); } else if (e is StringLiteral) { type = e.isBinary ? const ResolvedType(type: BasicType.blob) : _textType; session._hintNullability(e, false); } else if (e is BooleanLiteral) { type = const ResolvedType.bool(); session._hintNullability(e, false); } else if (e is NumericLiteral) { type = e.isInt ? _intType : _realType; session._hintNullability(e, false); } session._checkAndResolve(e, type, arg); } @override void visitVariable(Variable e, TypeExpectation arg) { _inferAsVariable(e, arg); } @override void visitDartPlaceholder(DartPlaceholder e, TypeExpectation arg) { if (e is DartExpressionPlaceholder) { _inferAsVariable(e, arg); } else { super.visitDartPlaceholder(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, arg.defaultType())); } visitChildren(e, arg); } @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, 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) { // 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 .._addRelation(NullableIfSomeOtherIs(e, e.childNodes)) .._addRelation(HaveSameType(e.lower, e.upper)) .._addRelation(HaveSameType(e.check, e.lower)); } @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.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])); 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. const stringType = ResolvedType(type: BasicType.text); session._checkAndResolve(e, stringType, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); const childExpectation = ExactTypeExpectation.laxly(stringType); visit(e.left, childExpectation); visit(e.right, childExpectation); 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); session._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); session._addRelation(NullableIfSomeOtherIs(e, e.childNodes)); session._addRelation(CopyTypeFrom(e.inside, 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, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.operand])); visit(e.operand, const NoTypeExpectation()); } @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); _lazyCopy(e, resolved); } @override void visitInvocation(SqlInvocation e, TypeExpectation arg) { final type = _resolveInvocation(e); if (type != null) { session._checkAndResolve(e, type, arg); } final visited = _resolveFunctionArguments(e); for (final child in e.childNodes) { if (!visited.contains(child)) { visit(child, const NoTypeExpectation()); } } } ResolvedType _resolveInvocation(SqlInvocation e) { final params = e.expandParameters(); void nullableIfChildIs() { session._addRelation(NullableIfSomeOtherIs(e, params)); } 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 _intType; } else { return _realType; } // ignore: dead_code throw AssertionError(); // required so that this switch compiles case 'sum': session._addRelation(CopyAndCast(e, params.first, CastMode.numeric)); session._addRelation(DefaultType(e, _realType)); nullableIfChildIs(); return null; case 'lower': case 'ltrim': case 'printf': case 'replace': case 'rtrim': case 'substr': case 'trim': case 'upper': case 'group_concat': nullableIfChildIs(); return _textType; case 'date': case 'time': case 'datetime': case 'julianday': case 'strftime': case 'char': case 'hex': case 'quote': case 'soundex': case 'sqlite_compileoption_set': case 'sqlite_version': case 'typeof': return _textType; 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': return _intType; case 'instr': case 'length': case 'unicode': nullableIfChildIs(); return _intType; case 'randomblob': case 'zeroblob': return const ResolvedType(type: BasicType.blob); case 'total': case 'avg': case 'percent_rank': case 'cume_dist': return _realType; case 'abs': case 'likelihood': case 'likely': case 'unlikely': session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'coalesce': case 'ifnull': session._addRelation(CopyEncapsulating(e, params)); return null; case 'nullif': session._hintNullability(e, true); session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'first_value': case 'last_value': case 'lag': case 'lead': case 'nth_value': session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'max': case 'min': session._hintNullability(e, true); session._addRelation(CopyEncapsulating(e, params)); return null; } final options = session.options; if (options.enableJson1) { switch (lowercaseName) { case 'json': case 'json_array': case 'json_insert': case 'json_replace': case 'json_set': case 'json_object': case 'json_patch': case 'json_remove': case 'json_quote': case 'json_group_array': case 'json_group_object': return _textType; case 'json_type': return _textType; case 'json_valid': return const ResolvedType.bool(); case 'json_extract': return null; case 'json_array_length': return _intType; } } if (options.addedFunctions.containsKey(lowercaseName)) { return options.addedFunctions[lowercaseName] .inferReturnType(session.context, e, params) ?.type; } session.context.reportError(AnalysisError( type: AnalysisErrorType.unknownFunction, message: 'Function ${e.name} could not be found', )); return null; } Set _resolveFunctionArguments(SqlInvocation e) { final params = e.expandParameters(); final visited = {}; final name = e.name.toLowerCase(); if (name == 'nth_value' && 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); } return visited; } void _handleColumn(Column column) { if (session.graph.knowsType(column)) return; if (column is TableColumn) { session._markTypeResolved(column, column.type); } else if (column is ExpressionColumn) { _lazyCopy(column, column.expression); } else if (column is DelegatedColumn && column.innerColumn != null) { _handleColumn(column.innerColumn); _lazyCopy(column, column.innerColumn); } } void _lazyCopy(Typeable to, Typeable from) { if (session.graph.knowsType(from)) { session._markTypeResolved(to, session.typeOf(from)); } else { session._addRelation(CopyTypeFrom(to, from)); } } void _handleWhereClause(HasWhereClause stmt) { if (stmt.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(stmt.where, const ExactTypeExpectation.laxly(ResolvedType.bool())); } } 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) { stmt.resolvedColumns.forEach(resolver._handleColumn); } } } lib/src/analysis/types2/types.dart0000644000175000017500000000363313611657705017162 0ustar00pubpub00000000000000import '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) { _expectIsPossible(r, expectation); _markTypeResolved(t, r); } /// Returns the inferred type of [t], or `null` if it couldn't be inferred. ResolvedType typeOf(Typeable t) { return graph[t]; } void _addRelation(TypeRelation relationship) { graph.addRelation(relationship); } /// Check that [r] is compatible with [expectation]. /// /// This is not currently implemented. void _expectIsPossible(ResolvedType r, TypeExpectation expectation) {} /// This is not currently implemented. void _hintNullability(Typeable t, bool nullable) { assert(nullable != null); } /// 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/utils/expand_function_parameters.dart0000644000175000017500000000167013611657705023336 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Extension to expand parameters defined in a sql invocation, which is either /// a [FunctionExpression] or an [AggregateExpression]. extension ExpandParameters on SqlInvocation { /// Returns the expanded parameters of a function call. /// /// When a [StarFunctionParameter] is used, it's expanded to the /// [ReferenceScope.availableColumns]. /// 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. return scope.availableColumns.whereType().toList(); } throw ArgumentError('Unknown parameters: $sqlParameters'); } } lib/src/ast/ast.dart0000644000175000017500000001111513611657705014315 0ustar00pubpub00000000000000import 'package:collection/collection.dart'; import '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/meta.dart'; 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/expressions.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 'moor/declared_statement.dart'; part 'moor/import_statement.dart'; part 'moor/inline_dart.dart'; part 'moor/moor_file.dart'; part 'schema/column_definition.dart'; part 'schema/table_definition.dart'; part 'statements/block.dart'; part 'statements/create_table.dart'; part 'statements/create_index.dart'; part 'statements/create_trigger.dart'; part 'statements/delete.dart'; part 'statements/insert.dart'; part 'statements/select.dart'; part 'statements/statement.dart'; part 'statements/update.dart'; part 'visitor.dart'; /// 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; } /// The [ReferenceScope], which contains available tables, column references /// and functions for this node. ReferenceScope get scope { var node = this; while (node != null) { final scope = node.meta(); if (scope != null) return scope; node = node.parent; } throw StateError('No reference scope found in this or any parent node'); } /// 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); } /// 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. bool contentEquals(covariant AstNode other); @override String toString() { if (hasSpan) { return '$runtimeType: ${span.text}'; } return super.toString(); } } lib/src/ast/clauses/limit.dart0000644000175000017500000000141713611657705016307 0ustar00pubpub00000000000000part of '../ast.dart'; /// Base for limit statements. Without moor extensions, only [Limit] will be /// parsed. With moor 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; // nullable Limit({this.count, this.offsetSeparator, this.offset}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitLimit(this, arg); } @override Iterable get childNodes => [count, if (offset != null) offset]; @override bool contentEquals(Limit other) { return other.offsetSeparator?.type == offsetSeparator?.type; } } lib/src/ast/clauses/ordering.dart0000644000175000017500000000267113611657705017005 0ustar00pubpub00000000000000part of '../ast.dart'; /// Base for `ORDER BY` clauses. Without moor 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 moor /// extensions, only [OrderingTerm] will be parsed. With moor extensions, a /// [DartOrderingTermPlaceholder] can be parsed as well. abstract class OrderingTermBase extends AstNode {} class OrderBy extends AstNode implements OrderByBase { final List terms; OrderBy({this.terms}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderBy(this, arg); } @override Iterable get childNodes => terms; @override bool contentEquals(OrderBy other) { return true; } } enum OrderingMode { ascending, descending } class OrderingTerm extends AstNode implements OrderingTermBase { final Expression expression; final OrderingMode orderingMode; OrderingMode get resolvedOrderingMode => orderingMode ?? OrderingMode.ascending; OrderingTerm({this.expression, this.orderingMode}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderingTerm(this, arg); } @override Iterable get childNodes => [expression]; @override bool contentEquals(OrderingTerm other) { return other.orderingMode == orderingMode; } } lib/src/ast/clauses/with.dart0000644000175000017500000000414113611657705016141 0ustar00pubpub00000000000000part of '../ast.dart'; class WithClause extends AstNode { Token withToken; final bool recursive; Token recursiveToken; final List ctes; WithClause({@required this.recursive, @required this.ctes}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWithClause(this, arg); } @override Iterable get childNodes => ctes; @override bool contentEquals(WithClause other) => other.recursive == recursive; } class CommonTableExpression extends AstNode with ResultSet, VisibleToChildren { final String cteTableName; /// 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; final BaseSelectStatement as; Token asToken; IdentifierToken tableNameToken; List _cachedColumns; CommonTableExpression( {@required this.cteTableName, this.columnNames, @required this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCommonTableExpression(this, arg); } @override Iterable get childNodes => [as]; @override bool contentEquals(CommonTableExpression other) { return other.cteTableName == cteTableName; } @override List get resolvedColumns { final columnsOfSelect = as.resolvedColumns; // we don't override column names, so just return the columns declared by // the select statement if (columnNames == null) return columnsOfSelect; _cachedColumns ??= columnNames .map((name) => CommonTableExpressionColumn(name, null)) .toList(); if (columnsOfSelect != null) { // bind the CommonTableExpressionColumn to the real underlying column // returned by the select statement for (var i = 0; i < _cachedColumns.length; i++) { if (i < columnsOfSelect.length) { final selectColumn = columnsOfSelect[i]; _cachedColumns[i].innerColumn = selectColumn; } } } return _cachedColumns; } } lib/src/ast/common/queryables.dart0000644000175000017500000001044513611657705017177 0ustar00pubpub00000000000000part of '../ast.dart'; /// Marker interface for something that can appear after a "FROM" in a select /// statement. abstract class Queryable extends AstNode { @override R accept(AstVisitor visitor, A arg) { return visitor.visitQueryable(this, arg); } T when({ @required T Function(TableReference) isTable, @required T Function(SelectStatementAsSource) isSelect, @required T Function(JoinClause) isJoin, }) { 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); } throw StateError('Unknown subclass'); } } /// https://www.sqlite.org/syntax/table-or-subquery.html /// Marker interface abstract class TableOrSubquery extends Queryable {} /// 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, VisibleToChildren { final String tableName; Token tableNameToken; @override final String as; TableReference(this.tableName, [this.as]); @override Iterable get childNodes => const []; @override bool contentEquals(TableReference other) { return other.tableName == tableName && other.as == as; } @override ResultSet get resultSet { return resolved as ResultSet; } } /// 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; final SelectStatement statement; SelectStatementAsSource({@required this.statement, this.as}); @override Iterable get childNodes => [statement]; @override bool contentEquals(SelectStatementAsSource other) { return other.as == as; } } /// https://www.sqlite.org/syntax/join-clause.html class JoinClause extends Queryable { final TableOrSubquery primary; final List joins; JoinClause({@required this.primary, @required this.joins}); @override Iterable get childNodes => [primary, ...joins]; @override bool contentEquals(JoinClause other) { return true; // equality is defined by child nodes } } enum JoinOperator { none, // just JOIN, no other keywords comma, left, leftOuter, inner, cross, } class Join extends AstNode { final bool natural; final JoinOperator operator; final TableOrSubquery query; final JoinConstraint constraint; Join( {this.natural = false, @required this.operator, @required this.query, @required this.constraint}); @override Iterable get childNodes { return [ query, if (constraint is OnConstraint) (constraint as OnConstraint).expression ]; } @override bool contentEquals(Join other) { if (other.natural != natural || other.operator != operator) { return false; } if (constraint is OnConstraint) { return other.constraint is OnConstraint; } else if (constraint is UsingConstraint) { final typedConstraint = constraint as UsingConstraint; if (other.constraint is! UsingConstraint) { return false; } final typedOther = other.constraint as UsingConstraint; return const ListEquality() .equals(typedConstraint.columnNames, typedOther.columnNames); } return true; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoin(this, arg); } } /// https://www.sqlite.org/syntax/join-constraint.html abstract class JoinConstraint {} class OnConstraint extends JoinConstraint { final Expression expression; OnConstraint({@required this.expression}); } class UsingConstraint extends JoinConstraint { final List columnNames; UsingConstraint({@required this.columnNames}); } lib/src/ast/common/renamable.dart0000644000175000017500000000010613506466600016735 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Renamable { String get as; } lib/src/ast/common/tuple.dart0000644000175000017500000000124113611657705016146 0ustar00pubpub00000000000000part of '../ast.dart'; /// A tuple of values, denotes in brackets. `(, ..., )`. /// /// Notice that this class extends [Expression] because the type inference /// algorithm works best when tuples are treated as expressions. Syntactically, /// tuples aren't expressions. class Tuple extends Expression { /// The expressions appearing in this tuple. final List expressions; Tuple({@required this.expressions}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTuple(this, arg); } @override List get childNodes => expressions; @override bool contentEquals(Tuple other) => true; } lib/src/ast/expressions/aggregate.dart0000644000175000017500000001440213611657705020040 0ustar00pubpub00000000000000part of '../ast.dart'; class AggregateExpression extends Expression implements SqlInvocation, ReferenceOwner { final IdentifierToken function; @override String get name => function.identifier; @override final FunctionParameters parameters; final Expression filter; @override Referencable resolved; 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. final 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; AggregateExpression( {@required this.function, @required this.parameters, this.filter, this.windowDefinition, this.windowName}) // either window definition or name must be null : assert((windowDefinition == null) != (windowName == null)); @override R accept(AstVisitor visitor, A arg) { return visitor.visitAggregateExpression(this, arg); } @override Iterable get childNodes { return [ parameters, if (filter != null) filter, if (windowDefinition != null) windowDefinition, ]; } @override bool contentEquals(AggregateExpression other) { return other.name == name && other.windowName == windowName; } } /// A window declaration that appears in a `SELECT` statement like /// `WINDOW AS `. It can be referenced from an /// [AggregateExpression] if it uses the same name. class NamedWindowDeclaration with Referencable { final String name; final WindowDefinition definition; NamedWindowDeclaration(this.name, this.definition); } class WindowDefinition extends AstNode { final String baseWindowName; final List partitionBy; final OrderByBase orderBy; final 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 Iterable get childNodes => [...partitionBy, if (orderBy != null) orderBy, frameSpec]; @override bool contentEquals(WindowDefinition other) { return other.baseWindowName == baseWindowName; } } class FrameSpec extends AstNode { final FrameType type; final ExcludeMode excludeMode; final FrameBoundary start; final FrameBoundary end; FrameSpec({ this.type = FrameType.range, this.start = const FrameBoundary.unboundedPreceding(), this.end = const FrameBoundary.currentRow(), this.excludeMode = ExcludeMode.noOthers, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFrameSpec(this, arg); } @override Iterable get childNodes => [ if (start.isExpressionOffset) start.offset, if (end.isExpressionOffset) end.offset, ]; @override bool contentEquals(FrameSpec other) { return other.type == type && other.excludeMode == excludeMode && other.start == start && other.end == end; } } /// 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. final 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; const FrameBoundary._(this._type, this.preceding, {this.offset}); const FrameBoundary.unboundedPreceding() : this._(_BoundaryType.unboundedOffset, true); const FrameBoundary.unboundedFollowing() : this._(_BoundaryType.unboundedOffset, false); const FrameBoundary.currentRow() : this._(_BoundaryType.currentRow, false); const FrameBoundary.preceding(Expression amount) : this._(_BoundaryType.exprOffset, true, offset: amount); const 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 ==(dynamic 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.contentEquals(offset) && typedOther.preceding == preceding; } } lib/src/ast/expressions/case.dart0000644000175000017500000000163313611657705017027 0ustar00pubpub00000000000000part of '../ast.dart'; class CaseExpression extends Expression { final Expression base; // can be null final List whens; final Expression elseExpr; CaseExpression({this.base, @required this.whens, this.elseExpr}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCaseExpression(this, arg); } @override Iterable get childNodes => [if (base != null) base, ...whens, if (elseExpr != null) elseExpr]; @override bool contentEquals(CaseExpression other) => true; } class WhenComponent extends AstNode { final Expression when; final Expression then; WhenComponent({this.when, this.then}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWhen(this, arg); } @override Iterable get childNodes => [when, then]; @override bool contentEquals(WhenComponent other) => true; } lib/src/ast/expressions/cast.dart0000644000175000017500000000075713611657705017054 0ustar00pubpub00000000000000part of '../ast.dart'; /// A `CAST( AS )` expression. class CastExpression extends Expression { final Expression operand; final String typeName; CastExpression(this.operand, this.typeName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCastExpression(this, arg); } @override Iterable get childNodes => [operand]; @override bool contentEquals(CastExpression other) { return other.typeName == typeName; } } lib/src/ast/expressions/expressions.dart0000644000175000017500000000013113506466600020461 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Expression extends AstNode implements Typeable {} lib/src/ast/expressions/function.dart0000644000175000017500000000366413611657705017747 0ustar00pubpub00000000000000part of '../ast.dart'; /// Interface for function calls, either a [FunctionExpression] or a /// [AggregateExpression]. abstract class SqlInvocation extends Expression { /// The name of the function being called String get name; FunctionParameters get parameters; } class FunctionExpression extends Expression with ReferenceOwner implements SqlInvocation { @override final String name; @override final FunctionParameters parameters; FunctionExpression({@required this.name, @required this.parameters}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFunction(this, arg); } @override Iterable get childNodes { return [parameters]; } @override bool contentEquals(FunctionExpression other) { return other.name == name; } } /// 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 Iterable get childNodes => const Iterable.empty(); @override bool contentEquals(StarFunctionParameter other) { return true; } } class ExprFunctionParameters extends FunctionParameters { final bool distinct; final List parameters; ExprFunctionParameters({this.parameters = const [], this.distinct = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExpressionFunctionParameters(this, arg); } @override List get childNodes => parameters; @override bool contentEquals(ExprFunctionParameters other) { return other.distinct == distinct && other.parameters == parameters; } } lib/src/ast/expressions/literals.dart0000644000175000017500000000370213611657705017732 0ustar00pubpub00000000000000part of '../ast.dart'; // https://www.sqlite.org/syntax/literal-value.html @optionalTypeArgs abstract class Literal extends Expression { final Token token; T get value; Literal(this.token); @override final Iterable childNodes = const []; } class NullLiteral extends Literal { NullLiteral(Token token) : super(token); @override Null get value => null; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNullLiteral(this, arg); } @override bool contentEquals(NullLiteral other) => true; } class NumericLiteral extends Literal { @override final num value; bool get isInt => value.toInt() == value; NumericLiteral(this.value, Token token) : super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumericLiteral(this, arg); } @override bool contentEquals(NumericLiteral other) => other.value == value; } class BooleanLiteral extends Literal { @override final bool value; BooleanLiteral.withFalse(Token token) : value = false, super(token); BooleanLiteral.withTrue(Token token) : value = true, super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBooleanLiteral(this, arg); } @override bool contentEquals(BooleanLiteral other) { return other.value == value; } } class StringLiteral extends Literal { @override final String value; final bool isBinary; StringLiteral(StringLiteralToken token) : value = token.value, isBinary = token.binary, super(token); StringLiteral.from(Token token, this.value, {this.isBinary = false}) : super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitStringLiteral(this, arg); } @override bool contentEquals(StringLiteral other) { return other.isBinary == isBinary && other.value == value; } } lib/src/ast/expressions/reference.dart0000644000175000017500000000205513611657705020051 0ustar00pubpub00000000000000part 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 { final String tableName; final String columnName; Column get resolvedColumn => resolved as Column; Reference({this.tableName, this.columnName}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitReference(this, arg); } @override Iterable get childNodes => const []; @override bool contentEquals(Reference other) { return other.tableName == tableName && other.columnName == columnName; } @override String toString() { if (tableName != null) { return '$tableName.$columnName'; } else { return columnName; } } } lib/src/ast/expressions/simple.dart0000644000175000017500000001156013611657705017405 0ustar00pubpub00000000000000part of '../ast.dart'; class UnaryExpression extends Expression { final Token operator; final Expression inner; UnaryExpression(this.operator, this.inner); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUnaryExpression(this, arg); } @override Iterable get childNodes => [inner]; @override bool contentEquals(UnaryExpression other) { return other.operator.type == operator.type; } } class CollateExpression extends UnaryExpression { final Token collateFunction; CollateExpression( {@required Token operator, @required Expression inner, @required this.collateFunction}) : super(operator, inner); @override bool contentEquals(CollateExpression other) { return super.contentEquals(other) && other.collateFunction.type == collateFunction.type; } } class BinaryExpression extends Expression { final Token operator; final Expression left; final Expression right; BinaryExpression(this.left, this.operator, this.right); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBinaryExpression(this, arg); } @override Iterable get childNodes => [left, right]; @override bool contentEquals(BinaryExpression other) { return other.operator.type == operator.type; } } /// A like, glob, match or regexp expression. class StringComparisonExpression extends Expression { final bool not; final Token operator; final Expression left; final Expression right; final 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 Iterable get childNodes => [left, right, if (escape != null) escape]; @override bool contentEquals(StringComparisonExpression other) => other.not == not; } /// `(NOT)? $left IS $right` class IsExpression extends Expression { final bool negated; final Expression left; final Expression right; IsExpression(this.negated, this.left, this.right); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIsExpression(this, arg); } @override Iterable get childNodes => [left, right]; @override bool contentEquals(IsExpression other) { return other.negated == negated; } } class IsNullExpression extends Expression { final 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 Iterable get childNodes => [operand]; @override bool contentEquals(IsNullExpression other) { return other.negated == negated; } } /// `$check BETWEEN $lower AND $upper` class BetweenExpression extends Expression { final bool not; final Expression check; final Expression lower; final Expression upper; BetweenExpression({this.not = false, this.check, this.lower, this.upper}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBetweenExpression(this, arg); } @override List get childNodes => [check, lower, upper]; @override bool contentEquals(BetweenExpression other) => other.not == not; } /// `$left$ IN $inside`. class InExpression extends Expression { final bool not; final 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. final Expression inside; InExpression({this.not = false, @required this.left, @required this.inside}) : assert(inside is Tuple || inside is Variable || inside is SubQuery); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInExpression(this, arg); } @override List get childNodes => [left, inside]; @override bool contentEquals(InExpression other) => other.not == not; } // todo we might be able to remove a hack in the parser at _in() if we make // parentheses a subclass of tuples class Parentheses extends Expression { final Token openingLeft; final Expression expression; final Token closingRight; Parentheses(this.openingLeft, this.expression, this.closingRight) { setSpan(openingLeft, closingRight); } @override R accept(AstVisitor visitor, A arg) { return visitor.visitParentheses(this, arg); } @override Iterable get childNodes => [expression]; @override bool contentEquals(Parentheses other) => true; } lib/src/ast/expressions/subquery.dart0000644000175000017500000000151613611657705017773 0ustar00pubpub00000000000000part 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 { final BaseSelectStatement select; SubQuery({this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSubQuery(this, arg); } @override Iterable get childNodes => [select]; @override bool contentEquals(SubQuery other) => true; } class ExistsExpression extends Expression { final BaseSelectStatement select; ExistsExpression({@required this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExists(this, arg); } @override Iterable get childNodes => [select]; @override bool contentEquals(ExistsExpression other) => true; } lib/src/ast/expressions/variables.dart0000644000175000017500000000206213611657705020061 0ustar00pubpub00000000000000part of '../ast.dart'; mixin Variable on Expression { int resolvedIndex; } /// A "?" or "?123" variable placeholder class NumberedVariable extends Expression with Variable { final QuestionMarkVariableToken token; int get explicitIndex => token.explicitIndex; NumberedVariable(this.token) { resolvedIndex = explicitIndex; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumberedVariable(this, arg); } @override Iterable get childNodes => const []; @override bool contentEquals(NumberedVariable other) { return other.explicitIndex == explicitIndex; } } class ColonNamedVariable extends Expression with Variable { final ColonVariableToken token; String get name => token.name; ColonNamedVariable(this.token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitNamedVariable(this, arg); } @override Iterable get childNodes => []; @override bool contentEquals(ColonNamedVariable other) { return other.name == name; } } lib/src/ast/moor/declared_statement.dart0000644000175000017500000000626413611657705020342 0ustar00pubpub00000000000000part of '../ast.dart'; /// A declared statement inside a `.moor` file. It consists of an identifier, /// followed by a colon and the query to run. class DeclaredStatement extends Statement implements PartOfMoorFile { final DeclaredStatementIdentifier identifier; final CrudStatement statement; final List parameters; 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}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitMoorDeclaredStatement(this, arg); } @override Iterable get childNodes => [statement, if (parameters != null) ...parameters]; @override bool contentEquals(DeclaredStatement other) { return other.identifier == identifier; } } /// How a statement was declared in a moor 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 ==(dynamic 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 ==(dynamic 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 abstract class StatementParameter extends AstNode { @override R accept(AstVisitor visitor, A arg) { return visitor.visitMoorStatementParameter(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 { final Variable variable; final String typeName; Token as; VariableTypeHint(this.variable, this.typeName); @override Iterable get childNodes => [variable]; @override bool contentEquals(VariableTypeHint other) { return other.typeName == typeName; } } lib/src/ast/moor/import_statement.dart0000644000175000017500000000111613611657705020100 0ustar00pubpub00000000000000part of '../ast.dart'; /// An `import "file.dart";` statement that can appear inside a moor file. class ImportStatement extends Statement implements PartOfMoorFile { Token importToken; StringLiteralToken importString; final String importedFile; ImportStatement(this.importedFile); @override R accept(AstVisitor visitor, A arg) { return visitor.visitMoorImportStatement(this, arg); } @override final Iterable childNodes = const []; @override bool contentEquals(ImportStatement other) { return other.importedFile == importedFile; } } lib/src/ast/moor/inline_dart.dart0000644000175000017500000000501713611657705016776 0ustar00pubpub00000000000000part of '../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 moor's /// Dart API. /// /// At the moment, we support 4 kind of inline components: /// 1. expressions: Any expression can be used for moor: `SELECT * FROM table /// = $expr`. Generated code will write this as an `Expression` class from /// moor. /// 2. limits, which will be exposed as a `Limit` component from moor /// 3. A single order-by clause, which will be exposed as a `OrderingTerm` from /// moor. /// 4. A list of order-by clauses, which will be exposed as a `OrderBy` from /// moor. abstract class DartPlaceholder extends AstNode { final String name; DollarSignVariableToken token; DartPlaceholder._(this.name); @override final Iterable childNodes = const Iterable.empty(); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDartPlaceholder(this, arg); } bool _dartEquals(covariant DartPlaceholder other) => true; @override bool contentEquals(DartPlaceholder other) { return other.name == name && other._dartEquals(other); } T when( {T Function(DartExpressionPlaceholder) isExpression, T Function(DartLimitPlaceholder) isLimit, T Function(DartOrderingTermPlaceholder) isOrderingTerm, T Function(DartOrderByPlaceholder) isOrderBy}) { 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); } 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); } lib/src/ast/moor/moor_file.dart0000644000175000017500000000140613611657705016457 0ustar00pubpub00000000000000part of '../ast.dart'; /// Something that can appear as a top-level declaration inside a `.moor` file. abstract class PartOfMoorFile implements Statement {} /// A moor file. /// /// A moor file consists of [ImportStatement], followed by ddl statements, /// followed by [DeclaredStatement]s. class MoorFile extends AstNode { final List statements; MoorFile(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitMoorFile(this, arg); } @override Iterable get childNodes => statements; /// Returns the imports defined in this file. Iterable get imports => childNodes.whereType(); @override bool contentEquals(MoorFile other) => true; } lib/src/ast/schema/column_definition.dart0000644000175000017500000001360213611657705020476 0ustar00pubpub00000000000000part of '../ast.dart'; /// https://www.sqlite.org/syntax/column-def.html class ColumnDefinition extends AstNode { final String columnName; final String typeName; final 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 Iterable get childNodes => constraints; @override bool contentEquals(ColumnDefinition other) { return other.columnName == columnName && other.typeName == typeName; } /// 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(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, }) { if (this is NotNull) { return notNull?.call(this as NotNull); } 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 { throw Exception('Did not expect $runtimeType as a ColumnConstraint'); } } @visibleForOverriding bool _equalToConstraint(covariant ColumnConstraint other); @override bool contentEquals(ColumnConstraint other) { return other.name == name && _equalToConstraint(other); } } enum ConflictClause { rollback, abort, fail, ignore, replace } class NotNull extends ColumnConstraint { final ConflictClause onConflict; Token not; Token $null; NotNull(String name, {this.onConflict}) : super(name); @override final Iterable childNodes = const []; @override bool _equalToConstraint(NotNull other) => onConflict == other.onConflict; } class PrimaryKeyColumn extends ColumnConstraint { final bool autoIncrement; final ConflictClause onConflict; final OrderingMode mode; PrimaryKeyColumn(String name, {this.autoIncrement = false, this.mode, this.onConflict}) : super(name); @override Iterable get childNodes => const []; @override bool _equalToConstraint(PrimaryKeyColumn other) { return other.autoIncrement == autoIncrement && other.mode == mode && other.onConflict == onConflict; } } class UniqueColumn extends ColumnConstraint { final ConflictClause onConflict; UniqueColumn(String name, this.onConflict) : super(name); @override Iterable get childNodes => const []; @override bool _equalToConstraint(UniqueColumn other) { return other.onConflict == onConflict; } } class CheckColumn extends ColumnConstraint { final Expression expression; CheckColumn(String name, this.expression) : super(name); @override Iterable get childNodes => [expression]; @override bool _equalToConstraint(CheckColumn other) => true; } class Default extends ColumnConstraint { final Expression expression; Default(String name, this.expression) : super(name); @override Iterable get childNodes => [expression]; @override bool _equalToConstraint(Default other) => true; } class CollateConstraint extends ColumnConstraint { final String collation; CollateConstraint(String name, this.collation) : super(name); @override final Iterable childNodes = const []; @override bool _equalToConstraint(CollateConstraint other) => true; } class ForeignKeyColumnConstraint extends ColumnConstraint { final ForeignKeyClause clause; ForeignKeyColumnConstraint(String name, this.clause) : super(name); @override bool _equalToConstraint(ForeignKeyColumnConstraint other) => true; @override Iterable get childNodes => [clause]; } /// A `MAPPED BY` constraint, which is only parsed for moor 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(String name, this.mapper) : super(name); @override bool _equalToConstraint(MappedBy other) { return other.mapper.dartCode == mapper.dartCode; } @override final Iterable childNodes = const []; } /// A `JSON KEY xyz` constraint which, which is only parsed for moor files. class JsonKey extends ColumnConstraint { Token json; Token key; IdentifierToken jsonNameToken; @override final Iterable childNodes = const []; String get jsonKey => jsonNameToken.identifier; JsonKey(String name, this.jsonNameToken) : super(name); @override bool _equalToConstraint(JsonKey other) { return other.jsonKey == jsonKey; } } lib/src/ast/schema/table_definition.dart0000644000175000017500000000455213611657705020274 0ustar00pubpub00000000000000part of '../ast.dart'; enum ReferenceAction { setNull, setDefault, cascade, restrict, noAction } class ForeignKeyClause extends AstNode { final TableReference foreignTable; final List columnNames; final ReferenceAction onDelete; final ReferenceAction onUpdate; ForeignKeyClause( {@required this.foreignTable, @required this.columnNames, this.onDelete, this.onUpdate}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitForeignKeyClause(this, arg); } @override Iterable get childNodes => [foreignTable, ...columnNames]; @override bool contentEquals(ForeignKeyClause other) { return other.onDelete == onDelete && other.onUpdate == onUpdate; } } 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); } @override bool contentEquals(TableConstraint other) { return other.name == name && _constraintEquals(other); } @visibleForOverriding bool _constraintEquals(covariant TableConstraint other); } class KeyClause extends TableConstraint { final bool isPrimaryKey; final List indexedColumns; final ConflictClause onConflict; bool get isUnique => !isPrimaryKey; KeyClause(String name, {@required this.isPrimaryKey, @required this.indexedColumns, this.onConflict}) : super(name); @override bool _constraintEquals(KeyClause other) { return other.isPrimaryKey == isPrimaryKey && other.onConflict == onConflict; } @override Iterable get childNodes => indexedColumns; } class CheckTable extends TableConstraint { final Expression expression; CheckTable(String name, this.expression) : super(name); @override bool _constraintEquals(CheckTable other) => true; @override Iterable get childNodes => [expression]; } class ForeignKeyTableConstraint extends TableConstraint { final List columns; final ForeignKeyClause clause; ForeignKeyTableConstraint(String name, {@required this.columns, @required this.clause}) : super(name); @override bool _constraintEquals(ForeignKeyTableConstraint other) => true; @override Iterable get childNodes => [...columns, clause]; } lib/src/ast/statements/block.dart0000644000175000017500000000065613611657705017017 0ustar00pubpub00000000000000part of '../ast.dart'; /// BLOCK = 'BEGIN' < CRUD-STATEMENT ';' > 'END' class Block extends AstNode { Token begin; Token end; final List statements; Block(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBlock(this, arg); } @override Iterable get childNodes => statements; @override bool contentEquals(Block other) => true; } lib/src/ast/statements/create_index.dart0000644000175000017500000000331613611657705020353 0ustar00pubpub00000000000000part of '../ast.dart'; class CreateIndexStatement extends Statement implements CreatingStatement, HasWhereClause { final String indexName; final bool unique; final bool ifNotExists; IdentifierToken nameToken; final TableReference on; final List columns; @override final 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 Iterable get childNodes => [on, ...columns, if (where != null) where]; @override bool contentEquals(CreateIndexStatement other) { return other.indexName == indexName; } } /// 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. final Expression expression; // nullable 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 bool contentEquals(IndexedColumn other) => other.ordering == ordering; } lib/src/ast/statements/create_table.dart0000644000175000017500000000567213611657705020342 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class TableInducingStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String tableName; /// Specific to moor. Overrides the name of the data class used to hold a /// result for of this table. Will be null when the moor extensions are not /// enabled or if no name has been set. final String overriddenDataClassName; Token tableNameToken; TableInducingStatement._(this.ifNotExists, this.tableName, [this.overriddenDataClassName]); @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 { final List columns; final List tableConstraints; final bool withoutRowId; Token openingBracket; Token closingBracket; CreateTableStatement( {bool ifNotExists = false, @required String tableName, this.columns = const [], this.tableConstraints = const [], this.withoutRowId = false, String overriddenDataClassName}) : super._(ifNotExists, tableName, overriddenDataClassName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateTableStatement(this, arg); } @override Iterable get childNodes => [...columns, ...tableConstraints]; @override bool contentEquals(CreateTableStatement other) { return other.ifNotExists == ifNotExists && other.tableName == tableName && other.withoutRowId == withoutRowId && other.overriddenDataClassName == overriddenDataClassName; } } 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 [], String overriddenDataClassName, }) : super._(ifNotExists, tableName, overriddenDataClassName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateVirtualTableStatement(this, arg); } @override Iterable get childNodes => const []; @override bool contentEquals(CreateVirtualTableStatement other) { return other.ifNotExists == ifNotExists && other.tableName == tableName && other.moduleName == moduleName && const ListEquality().equals(other.argumentContent, argumentContent); } } lib/src/ast/statements/create_trigger.dart0000644000175000017500000000450113611657705020704 0ustar00pubpub00000000000000part of '../ast.dart'; /// 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; final TriggerTarget target; final TableReference onTable; final Expression when; final 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 Iterable get childNodes sync* { if (target is UpdateTarget) yield* (target as UpdateTarget).columnNames; yield onTable; if (when != null) yield when; yield action; } @override bool contentEquals(CreateTriggerStatement other) { return other.ifNotExists == ifNotExists && other.triggerName == triggerName && other.mode == mode && other.target == target; } } enum TriggerMode { before, after, insteadOf } abstract class TriggerTarget { const TriggerTarget._(); @override int get hashCode => runtimeType.hashCode; @override bool operator ==(dynamic other) => other.runtimeType == runtimeType; /// 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 { const DeleteTarget() : super._(); @override bool get introducesNew => false; @override bool get introducesOld => true; } class InsertTarget extends TriggerTarget { const InsertTarget() : super._(); @override bool get introducesNew => true; @override bool get introducesOld => false; } class UpdateTarget extends TriggerTarget { final List columnNames; UpdateTarget(this.columnNames) : super._(); @override bool get introducesNew => true; @override bool get introducesOld => true; } lib/src/ast/statements/delete.dart0000644000175000017500000000114413611657705017160 0ustar00pubpub00000000000000part of '../ast.dart'; class DeleteStatement extends CrudStatement implements HasWhereClause { final TableReference from; @override final Expression where; DeleteStatement({WithClause withClause, @required this.from, this.where}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeleteStatement(this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause, from, if (where != null) where, ]; @override bool contentEquals(DeleteStatement other) => true; } lib/src/ast/statements/insert.dart0000644000175000017500000000476113611657705017232 0ustar00pubpub00000000000000part of '../ast.dart'; enum InsertMode { insert, replace, insertOrReplace, insertOrRollback, insertOrAbort, insertOrFail, insertOrIgnore } class InsertStatement extends CrudStatement { final InsertMode mode; final TableReference table; final List targetColumns; final InsertSource source; List get resolvedTargetColumns { if (targetColumns.isNotEmpty) { return targetColumns.map((c) => c.resolvedColumn).toList(); } else { // no columns declared - assume all columns from the table return table.resultSet?.resolvedColumns; } } // todo parse upsert clauses InsertStatement( {WithClause withClause, this.mode = InsertMode.insert, @required this.table, @required this.targetColumns, @required this.source}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInsertStatement(this, arg); } @override Iterable get childNodes sync* { if (withClause != null) yield withClause; yield table; yield* targetColumns; yield* source.childNodes; } @override bool contentEquals(InsertStatement other) { return other.mode == mode && other.source.runtimeType == source.runtimeType; } } abstract class InsertSource { Iterable get childNodes; const InsertSource(); T when( {T Function(ValuesSource) isValues, T Function(SelectInsertSource) isSelect, T Function(DefaultValues) isDefaults}) { if (this is ValuesSource) { return isValues?.call(this as ValuesSource); } else if (this is SelectInsertSource) { return isSelect?.call(this as SelectInsertSource); } else if (this is DefaultValues) { return isDefaults?.call(this as DefaultValues); } else { throw StateError('Did not expect $runtimeType as InsertSource'); } } } /// Uses a list of values for an insert statement (`VALUES (a, b, c)`). class ValuesSource extends InsertSource { final List values; ValuesSource(this.values); @override Iterable get childNodes => values; } /// Inserts the rows returned by [stmt]. class SelectInsertSource extends InsertSource { final BaseSelectStatement stmt; SelectInsertSource(this.stmt); @override Iterable get childNodes => [stmt]; } /// Use `DEFAULT VALUES` for an insert statement. class DefaultValues extends InsertSource { const DefaultValues(); @override Iterable get childNodes => const []; } lib/src/ast/statements/select.dart0000644000175000017500000001076513611657705017206 0ustar00pubpub00000000000000part of '../ast.dart'; 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._(WithClause withClause) : super._(withClause); } class SelectStatement extends BaseSelectStatement implements HasWhereClause { final bool distinct; final List columns; final List from; @override final Expression where; final GroupBy groupBy; final List windowDeclarations; final OrderByBase orderBy; final LimitBase limit; SelectStatement( {WithClause withClause, this.distinct = false, 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 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, ]; } @override bool contentEquals(SelectStatement other) { return other.distinct == distinct; } } class CompoundSelectStatement extends BaseSelectStatement { final SelectStatement base; final 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 bool contentEquals(CompoundSelectStatement other) { // this class doesn't contain anything but child nodes return true; } } abstract class ResultColumn extends AstNode { @override R accept(AstVisitor visitor, A arg) { return visitor.visitResultColumn(this, arg); } } /// 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 bool contentEquals(StarResultColumn other) { return other.tableName == tableName; } } class ExpressionResultColumn extends ResultColumn implements Renamable, Referencable { final Expression expression; @override final String as; ExpressionResultColumn({@required this.expression, this.as}); @override Iterable get childNodes => [expression]; @override bool contentEquals(ExpressionResultColumn other) { return other.as == as; } } class GroupBy extends AstNode { /// The list of expressions that form the partition final List by; final Expression having; GroupBy({@required this.by, this.having}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitGroupBy(this, arg); } @override Iterable get childNodes => [...by, if (having != null) having]; @override bool contentEquals(GroupBy other) { return true; // Defined via child nodes } } enum CompoundSelectMode { union, unionAll, intersect, except, } class CompoundSelectPart extends AstNode { final CompoundSelectMode mode; final SelectStatement 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 bool contentEquals(CompoundSelectPart other) => mode == other.mode; } lib/src/ast/statements/statement.dart0000644000175000017500000000141513611657705017723 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Statement extends AstNode { Token semicolon; } /// A statement that reads from an existing table structure and has an optional /// `WITH` clause. abstract class CrudStatement extends Statement { WithClause withClause; CrudStatement._(this.withClause); } /// Interface for statements that have a primary where clause (select, update, /// delete). abstract class HasWhereClause extends Statement { Expression get where; } /// Marker interface for statements that change the table structure. abstract class SchemaStatement extends Statement implements PartOfMoorFile {} /// Marker interface for schema statements that create a schematic entity. abstract class CreatingStatement extends SchemaStatement { String get createdName; } lib/src/ast/statements/update.dart0000644000175000017500000000312213611657705017176 0ustar00pubpub00000000000000part of '../ast.dart'; 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 HasWhereClause { final FailureMode or; final TableReference table; final List set; @override final Expression where; UpdateStatement( {WithClause withClause, this.or, @required this.table, @required this.set, this.where}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpdateStatement(this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause, table, ...set, if (where != null) where, ]; @override bool contentEquals(UpdateStatement other) { return other.or == or; } static FailureMode failureModeFromToken(TokenType token) { return _tokensToMode[token]; } } class SetComponent extends AstNode { final Reference column; final Expression expression; SetComponent({@required this.column, @required this.expression}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSetComponent(this, arg); } @override Iterable get childNodes => [column, expression]; @override bool contentEquals(SetComponent other) => true; } lib/src/ast/visitor.dart0000644000175000017500000002505613611657705015236 0ustar00pubpub00000000000000part of 'ast.dart'; abstract class AstVisitor { R visitSelectStatement(SelectStatement e, A arg); R visitCompoundSelectStatement(CompoundSelectStatement e, A arg); R visitCompoundSelectPart(CompoundSelectPart e, A arg); R visitResultColumn(ResultColumn 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 visitWithClause(WithClause 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 visitQueryable(Queryable e, A arg); R visitJoin(Join e, A arg); R visitGroupBy(GroupBy e, A arg); R visitSetComponent(SetComponent 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 visitLiteral(Literal e, A arg); R visitNumericLiteral(Literal e, A arg); R visitNullLiteral(NullLiteral e, A arg); R visitBooleanLiteral(BooleanLiteral e, A arg); R visitStringLiteral(StringLiteral e, A arg); R visitCastExpression(CastExpression e, A arg); R visitBinaryExpression(BinaryExpression e, A arg); R visitStringComparison(StringComparisonExpression 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 visitAggregateExpression(AggregateExpression 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 visitMoorFile(MoorFile e, A arg); R visitMoorImportStatement(ImportStatement e, A arg); R visitMoorDeclaredStatement(DeclaredStatement e, A arg); R visitMoorStatementParameter(StatementParameter e, A arg); R visitDartPlaceholder(DartPlaceholder e, A arg); } /// Visitor that walks down the entire tree, visiting all children in order. class RecursiveVisitor implements AstVisitor { // Statements @override R visitSelectStatement(SelectStatement 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 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 visitChildren(statement, arg); } @override R visitCompoundSelectPart(CompoundSelectPart e, A arg) { return visitChildren(e, arg); } // General clauses @override R visitResultColumn(ResultColumn e, A arg) { return visitChildren(e, arg); } @override R visitWithClause(WithClause e, A arg) { return visitChildren(e, arg); } @override R visitCommonTableExpression(CommonTableExpression e, A arg) { return visitChildren(e, arg); } @override R visitOrderBy(OrderBy e, A arg) { return visitChildren(e, arg); } @override R visitOrderingTerm(OrderingTerm e, A arg) { return visitChildren(e, arg); } @override R visitLimit(Limit e, A arg) { return visitChildren(e, arg); } @override R visitQueryable(Queryable e, A arg) { return visitChildren(e, arg); } @override R visitJoin(Join e, A arg) { return visitChildren(e, arg); } @override R visitGroupBy(GroupBy e, A arg) { return visitChildren(e, arg); } @override R visitSetComponent(SetComponent e, A arg) { return visitChildren(e, arg); } @override R visitColumnDefinition(ColumnDefinition e, A arg) { return visitChildren(e, arg); } @override R visitColumnConstraint(ColumnConstraint e, A arg) { return visitChildren(e, arg); } @override R visitTableConstraint(TableConstraint e, A arg) { return visitChildren(e, arg); } @override R visitForeignKeyClause(ForeignKeyClause e, A arg) { return visitChildren(e, arg); } @override R visitWindowDefinition(WindowDefinition e, A arg) { return visitChildren(e, arg); } @override R visitFrameSpec(FrameSpec e, A arg) { return visitChildren(e, arg); } @override R visitIndexedColumn(IndexedColumn e, A arg) { return visitChildren(e, arg); } @override R visitBlock(Block e, A arg) { return visitChildren(e, arg); } // Moor-specific additions @override R visitMoorFile(MoorFile e, A arg) { return visitChildren(e, arg); } @override R visitMoorImportStatement(ImportStatement e, A arg) { return visitStatement(e, arg); } @override R visitMoorDeclaredStatement(DeclaredStatement e, A arg) { return visitStatement(e, arg); } @override R visitDartPlaceholder(DartPlaceholder e, A arg) { return visitChildren(e, arg); } @override R visitMoorStatementParameter(StatementParameter e, A arg) { return visitChildren(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 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); } @override R visitLiteral(Literal e, A arg) { return visitExpression(e, arg); } @override R visitNullLiteral(NullLiteral e, A arg) { return visitLiteral(e, arg); } @override R visitNumericLiteral(Literal e, A arg) { return visitLiteral(e, arg); } @override R visitBooleanLiteral(BooleanLiteral e, A arg) { return visitLiteral(e, arg); } @override R visitStringLiteral(StringLiteral e, A arg) { return visitLiteral(e, arg); } @override R visitReference(Reference e, A arg) { return visitExpression(e, arg); } @override R visitFunction(FunctionExpression e, A arg) { return visitInvocation(e, arg); } R visitFunctionParameters(FunctionParameters e, A arg) { return visitChildren(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 visitAggregateExpression(AggregateExpression e, A arg) { return visitInvocation(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 visitChildren(e, arg); } @override R visitTuple(Tuple e, A arg) { return visitExpression(e, arg); } @override R visitParentheses(Parentheses e, A arg) { return e.expression.accept(this, arg); } @override R visitInExpression(InExpression 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 visitInvocation(SqlInvocation e, A arg) { return visitExpression(e, arg); } R visitExpression(Expression e, A arg) { return visitChildren(e, arg); } R visit(AstNode e, A arg) => e.accept(this, arg); R visitNullable(AstNode e, A arg) => e?.accept(this, arg); @protected R visitChildren(AstNode e, A arg) => visitList(e.childNodes, arg); @protected R visitList(Iterable nodes, A arg) { for (final node in nodes) { node.accept(this, arg); } return null; } void visitExcept(AstNode node, AstNode skip, A arg) { for (final child in node.childNodes) { if (child != skip) { visit(child, arg); } } } } lib/src/engine/autocomplete/descriptions/description.dart0000644000175000017500000000243613545361247023743 0ustar00pubpub00000000000000part 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/references.dart0000644000175000017500000000062413611657705023537 0ustar00pubpub00000000000000part 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.knownTables.map((t) => t.escapedName); return tableNames.map((t) { return Suggestion(t, 1); }); } } lib/src/engine/autocomplete/descriptions/static.dart0000644000175000017500000000103113545361247022675 0ustar00pubpub00000000000000part 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/engine.dart0000644000175000017500000000730513611657705020160 0ustar00pubpub00000000000000import 'package:collection/collection.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/token.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 = []; UnmodifiableListView _hintsView; 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) { _hintsView = UnmodifiableListView(_hints); } /// 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.dart0000644000175000017500000000175413611657705021104 0ustar00pubpub00000000000000part 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/builtin_tables.dart0000644000175000017500000000164513563747057017221 0ustar00pubpub00000000000000import '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], ); } lib/src/engine/module/fts5.dart0000644000175000017500000001323613611657705016360 0ustar00pubpub00000000000000import 'package:meta/meta.dart'; import 'package:sqlparser/sqlparser.dart'; class Fts5Extension implements Extension { const Fts5Extension(); @override void register(SqlEngine engine) { engine.registerModule(_Fts5Module()); engine.registerFunctionHandler(const _Fts5Functions()); } } /// FTS5 module for `CREATE VIRTUAL TABLE USING fts5` support class _Fts5Module extends Module { _Fts5Module() : super('fts5'); @override Table parseTable(CreateVirtualTableStatement stmt) { // arguments with an equals sign are parameters passed to the fts5 module. // they're not part of the schema. final columnNames = stmt.argumentContent.where((arg) => !arg.contains('=')).map((c) { // actual syntax is return c.trim().split(' ').first; }); return _Fts5Table( name: stmt.tableName, columns: [ for (var arg in columnNames) TableColumn(arg, const ResolvedType(type: BasicType.text)), ], definition: stmt, ); } } class _Fts5Table extends Table { _Fts5Table( {@required String name, List columns, CreateVirtualTableStatement definition}) : super( name: name, resolvedColumns: [ ...columns, _Fts5RankColumn(), _Fts5TableColumn(name), ], definition: definition, ); } /// Provides type inference and lints for class _Fts5Functions 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) return const ResolveResult.unknown(); 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) { case 'bm25': return const ResolveResult(ResolvedType(type: BasicType.real)); case 'highlight': return const ResolveResult(ResolvedType(type: BasicType.text)); case 'snippet': return const ResolveResult(ResolvedType(type: BasicType.text)); } return const ResolveResult.unknown(); } @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 expectedArgCount = const { 'bm25': 1, 'highlight': 4, 'snippet': 6, }[call.name.toLowerCase()]; if (expectedArgCount != args.length) { context.reportError(AnalysisError( relevantNode: call, message: '${call.name} expects $expectedArgCount arguments, ' 'got ${args.length}.', type: AnalysisErrorType.other, )); 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 is! _Fts5TableColumn) { context.reportError(AnalysisError( relevantNode: args.first, message: 'Expected an fts5 table name here', 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.int)); } /// 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/module.dart0000644000175000017500000000475313611657705016770 0ustar00pubpub00000000000000import '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 { /// 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) {} } /// An sqlite module, which can be used in a `CREATE VIRTUAL TABLE` statement /// to find providers. abstract class Module implements Referencable, VisibleToChildren { /// 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); } lib/src/engine/options.dart0000644000175000017500000000211213611657705015674 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; class EngineOptions { /// Moor 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 bool useMoorExtensions; /// Enables functions declared in the `json1` module for analysis final bool enableJson1; /// Enables the new, experimental type inference. final bool enableExperimentalTypeInference; /// All [Extension]s that have been enabled in this sql engine. final List enabledExtensions; final List _addedFunctionHandlers = []; final Map addedFunctions = {}; EngineOptions({ this.useMoorExtensions = false, this.enableJson1 = false, this.enabledExtensions = const [], this.enableExperimentalTypeInference = false, }); void addFunctionHandler(FunctionHandler handler) { _addedFunctionHandlers.add(handler); for (final function in handler.functionNames) { addedFunctions[function.toLowerCase()] = handler; } } } lib/src/engine/sql_engine.dart0000644000175000017500000002513313611657705016335 0ustar00pubpub00000000000000import 'dart:collection'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types2/types.dart' as t2; import 'package:sqlparser/src/engine/module/fts5.dart'; import 'package:sqlparser/src/engine/options.dart'; import 'package:sqlparser/src/reader/parser/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'autocomplete/engine.dart'; import 'builtin_tables.dart'; class SqlEngine { /// All tables registered with [registerTable]. final List
knownTables = []; final List _knownModules = []; /// Internal options for this sql engine. final EngineOptions options; SchemaFromCreateTable _schemaReader; SqlEngine( {@Deprecated('Use SqlEngine.withOptions instead') bool useMoorExtensions = false, @Deprecated('Use SqlEngine.withOptions instead') bool enableJson1Module = false, @Deprecated('Use SqlEngine.withOptions instead') bool enableFts5 = false}) : this.withOptions(_constructOptions( // ignore: deprecated_member_use_from_same_package moor: useMoorExtensions, // ignore: deprecated_member_use_from_same_package json1: enableJson1Module, // ignore: deprecated_member_use_from_same_package fts5: enableFts5, )); SqlEngine.withOptions(this.options) { for (final extension in options.enabledExtensions) { extension.register(this); } registerTable(sqliteMaster); 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 ??= SchemaFromCreateTable(moorExtensions: options.useMoorExtensions); } /// Registers the [table], which means that it can later be used in sql /// statements. void registerTable(Table table) { knownTables.add(table); } /// 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); } ReferenceScope _constructRootScope({ReferenceScope parent}) { final scope = parent == null ? ReferenceScope(null) : parent.createChild(); for (final table in knownTables) { scope.register(table.name, table); } for (final module in _knownModules) { scope.register(module.name, module); } return scope; } /// Tokenizes the [source] into a list list [Token]s. Each [Token] contains /// information about where it appears in the [source] and a [TokenType]. /// /// 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 = Scanner(source, scanMoorTokens: options.useMoorExtensions); final tokens = scanner.scanTokens(); if (scanner.errors.isNotEmpty) { throw CumulatedTokenizerException(scanner.errors); } return tokens; } /// Parses a single [sql] statement into an AST-representation. ParseResult parse(String sql) { final tokens = tokenize(sql); final tokensForParser = tokens.where((t) => !t.invisibleToParser).toList(); final parser = Parser(tokensForParser, useMoor: options.useMoorExtensions); final stmt = parser.statement(); return ParseResult._(stmt, tokens, parser.errors, sql, null); } /// Parses a `.moor` file, which can consist of multiple statements and /// additional components like import statements. ParseResult parseMoorFile(String content) { assert(options.useMoorExtensions); final tokens = tokenize(content); final autoComplete = AutoCompleteEngine(tokens, this); final tokensForParser = tokens.where((t) => !t.invisibleToParser).toList(); final parser = Parser(tokensForParser, useMoor: true, autoComplete: autoComplete); final moorFile = parser.moorFile(); _attachRootScope(moorFile); return ParseResult._( moorFile, 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); return analyzeParsed(result, stmtOptions: stmtOptions); } /// 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; final context = _createContext(node, result.sql, stmtOptions); _analyzeContext(context); return context; } /// 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) { return AnalysisContext(node, sql, options, stmtOptions: stmtOptions, schemaSupport: schemaReader); } void _analyzeContext(AnalysisContext context) { final node = context.root; _attachRootScope(node); try { AstPreparingVisitor(context: context).start(node); node ..acceptWithoutArg(ColumnResolver(context)) ..acceptWithoutArg(ReferenceResolver(context)); if (options.enableExperimentalTypeInference) { final session = t2.TypeInferenceSession(context, options); final resolver = t2.TypeResolver(session); resolver.run(node); context.types2 = session.results; } else { node.acceptWithoutArg(TypeResolvingVisitor(context)); } node.acceptWithoutArg(LintingVisitor(options, context)); } catch (_) { rethrow; } } void _attachRootScope(AstNode root) { // calling node.referenceScope throws when no scope is set, we use the // nullable variant here final safeScope = root.selfAndParents .map((node) => node.meta()) .firstWhere((e) => e != null, orElse: () => null); root.scope = _constructRootScope(parent: safeScope); } static EngineOptions _constructOptions({bool moor, bool fts5, bool json1}) { final extensions = [ if (fts5) const Fts5Extension(), ]; return EngineOptions( useMoorExtensions: moor, enableJson1: json1, enabledExtensions: extensions, ); } } /// 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 || rootNode == null) 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/reader/parser/crud.dart0000644000175000017500000005756613611657705016456 0ustar00pubpub00000000000000part of 'parser.dart'; mixin CrudParser on ParserBase { CrudStatement _crud() { final withClause = _withClause(); if (_check(TokenType.select)) { 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); } 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'); 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, columnNames: columnNames, as: selectStmt, ) ..setSpan(name, _previous) ..asToken = asToken ..tableNameToken = name); } while (_matchOne(TokenType.comma)); return WithClause( recursive: recursive, ctes: ctes, ) ..setSpan(withToken, _previous) ..recursiveToken = recursiveToken ..withToken = withToken; } @override BaseSelectStatement _fullSelect() { final clause = _withClause(); return select(withClause: clause); } @override 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); } } } SelectStatement _selectNoCompound([WithClause 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 = []; do { resultColumns.add(_resultColumn()); } while (_match(const [TokenType.comma])); final from = _from(); final where = _where(); 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); } 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(); return CompoundSelectPart( mode: mode, select: select, ) ..firstModeToken = firstModeToken ..allToken = allToken ..setSpan(firstModeToken, _previous); } return null; } /// Parses a [ResultColumn] or throws if none is found. /// https://www.sqlite.org/syntax/result-column.html ResultColumn _resultColumn() { if (_match(const [TokenType.star])) { return StarResultColumn(null)..setSpan(_previous, _previous); } final positionBefore = _current; if (_match(const [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; if (_match(const [TokenType.dot]) && _match(const [TokenType.star])) { return StarResultColumn((identifier as IdentifierToken).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; } final tokenBefore = _peek; final expr = expression(); final as = _as(); return ExpressionResultColumn(expression: expr, as: as?.identifier) ..setSpan(tokenBefore, _previous); } /// 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; } } List _from() { if (!_matchOne(TokenType.from)) return []; // 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 it is one final join = _joinClause(start); if (join != null) { return [join]; } // not a join. Keep the TableOrSubqueries coming! final queries = [start]; while (_matchOne(TokenType.comma)) { queries.add(_tableOrSubquery()); } return queries; } TableOrSubquery _tableOrSubquery() { // this is what we're parsing: https://www.sqlite.org/syntax/table-or-subquery.html // we currently only support regular tables and nested selects final tableRef = _tableReference(); if (tableRef != null) { return tableRef; } else if (_matchOne(TokenType.leftParen)) { final first = _previous; final innerStmt = _selectNoCompound(); _consume(TokenType.rightParen, 'Expected a right bracket to terminate the inner select'); final alias = _as(); return SelectStatementAsSource( statement: innerStmt, as: alias?.identifier) ..setSpan(first, _previous); } _error('Expected a table name or a nested select statement'); } TableReference _tableReference() { _suggestHint(const TableNameDescription()); if (_matchOne(TokenType.identifier)) { // ignore the schema name, it's not supported. Besides that, we're on the // first branch in the diagram here https://www.sqlite.org/syntax/table-or-subquery.html final firstToken = _previous as IdentifierToken; final tableName = firstToken.identifier; final alias = _as(); return TableReference(tableName, alias?.identifier) ..setSpan(firstToken, _previous) ..tableNameToken = firstToken; } return null; } JoinClause _joinClause(TableOrSubquery start) { var operator = _parseJoinOperatorNoComma(); if (operator == null) { return null; } final joins = []; while (operator != null) { final first = _peekNext; final subquery = _tableOrSubquery(); final constraint = _joinConstraint(); JoinOperator resolvedOperator; if (operator.contains(TokenType.left)) { resolvedOperator = operator.contains(TokenType.outer) ? JoinOperator.leftOuter : JoinOperator.left; } else if (operator.contains(TokenType.inner)) { resolvedOperator = JoinOperator.inner; } else if (operator.contains(TokenType.cross)) { resolvedOperator = JoinOperator.cross; } else if (operator.contains(TokenType.comma)) { resolvedOperator = JoinOperator.comma; } else { resolvedOperator = JoinOperator.none; } joins.add(Join( natural: operator.contains(TokenType.natural), operator: resolvedOperator, query: subquery, constraint: constraint, )..setSpan(first, _previous)); // parse the next operator, if there is more than one join if (_matchOne(TokenType.comma)) { operator = [TokenType.comma]; } else { operator = _parseJoinOperatorNoComma(); } } return JoinClause(primary: start, joins: joins) ..setSpan(start.first, _previous); } /// Parses https://www.sqlite.org/syntax/join-operator.html, minus the comma. List _parseJoinOperatorNoComma() { if (_match(_startOperators)) { final operators = [_previous.type]; if (_previous.type == TokenType.join) { // just join, without any specific operators return operators; } else { // natural is a prefix, another operator can follow. if (_previous.type == TokenType.natural) { if (_match([TokenType.left, TokenType.inner, TokenType.cross])) { operators.add(_previous.type); } } if (_previous.type == TokenType.left && _matchOne(TokenType.outer)) { operators.add(_previous.type); } _consume(TokenType.join, 'Expected to see a join keyword here'); return operators; } } return null; } /// 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); } _error('Expected a constraint with ON or USING'); } /// Parses a where clause if there is one at the current position Expression _where() { if (_match(const [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(termPlaceholder.first, termPlaceholder.last); } return OrderBy(terms: terms)..setSpan(orderToken, _previous); } return null; } OrderingTermBase _orderingTerm() { final expr = expression(); final mode = _orderingModeOrNull(); // if there is no ASC or DESC 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 && expr is DartExpressionPlaceholder) { return DartOrderingTermPlaceholder(name: expr.name) ..setSpan(expr.first, expr.last); } return OrderingTerm(expression: expr, orderingMode: mode) ..setSpan(expr.first, _previous); } @override 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(); Expression where; if (table == null) { _error('Expected a table reference'); } if (_matchOne(TokenType.where)) { where = expression(); } return DeleteStatement( withClause: withClause, from: table, where: where, )..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 = []; do { final columnName = _consume(TokenType.identifier, 'Expected a column name to set') as IdentifierToken; final reference = Reference(columnName: columnName.identifier) ..setSpan(columnName, columnName); _consume(TokenType.equal, 'Expected = after the column name'); final expr = expression(); set.add(SetComponent(column: reference, expression: expr) ..setSpan(columnName, _previous)); } while (_matchOne(TokenType.comma)); final where = _where(); return UpdateStatement( withClause: withClause, or: failureMode, table: table, set: set, where: where, )..setSpan(withClause?.first ?? updateToken, _previous); } 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 clpsing parenthesis after column list'); } final source = _insertSource(); return InsertStatement( withClause: withClause, mode: insertMode, table: table, targetColumns: targetColumns, source: source, )..setSpan(withClause?.first ?? firstToken, _previous); } InsertSource _insertSource() { if (_matchOne(TokenType.$values)) { 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); } else if (_matchOne(TokenType.$default)) { _consume(TokenType.$values, 'Expected DEFAULT VALUES'); return const DefaultValues(); } else { return SelectInsertSource( _fullSelect() ?? _error('Expeced a select statement')); } } @override 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 = const 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 const 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 const FrameBoundary.unboundedPreceding(); } else { _consume(TokenType.following, 'Expected UNBOUNDED FOLLOWING'); return const 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'); } } lib/src/reader/parser/expressions.dart0000644000175000017500000003272113611657705020065 0ustar00pubpub00000000000000part of 'parser.dart'; /// Parses expressions. Expressions have the following precedence: /// - `-`, `+`, `~`, unary not /// - `||` (concatenation) /// - `*`, '/', '%' /// - `+`, `-` /// - `<<`, `>>`, `&`, `|` /// - `<`, `<=`, `>`, `>=` /// - `=`, `==`, `!=`, `<>`, `IS`, `IS NOT`, `IN`, `LIKE`, `GLOB`, `MATCH`, /// `REGEXP` /// - `AND` /// - `OR` /// - Case expressions mixin ExpressionParser on ParserBase { @override Expression expression() { return _case(); } Expression _case() { if (_matchOne(TokenType.$case)) { final caseToken = _previous; final base = _check(TokenType.when) ? null : _or(); final whens = []; Expression $else; while (_matchOne(TokenType.when)) { final whenToken = _previous; final whenExpr = _or(); _consume(TokenType.then, 'Expected THEN'); final then = _or(); whens.add(WhenComponent(when: whenExpr, then: then) ..setSpan(whenToken, _previous)); } if (_matchOne(TokenType.$else)) { $else = _or(); } _consume(TokenType.end, 'Expected END to finish the case operator'); return CaseExpression(whens: whens, base: base, elseExpr: $else) ..setSpan(caseToken, _previous); } 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); final inside = _variableOrNull() ?? _consumeTuple(orSubQuery: true); 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 not = _match(const [TokenType.not]); // special case: is not expression expression = IsExpression(not, expression, _comparison()) ..setSpan(first, _previous); } 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], _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 = _primary(); // 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(operator, _previous); } return expression; } @override Literal _literalOrNull() { final token = _peek; Literal _parseInner() { if (_matchOne(TokenType.numberLiteral)) { return NumericLiteral(_parseNumber(token.lexeme), token); } if (_matchOne(TokenType.stringLiteral)) { return StringLiteral(token as StringLiteralToken); } if (_matchOne(TokenType.$null)) { return NullLiteral(token); } if (_matchOne(TokenType.$true)) { return BooleanLiteral.withTrue(token); } if (_matchOne(TokenType.$false)) { return BooleanLiteral.withFalse(token); } // todo CURRENT_TIME, CURRENT_DATE, CURRENT_TIMESTAMP return null; } final literal = _parseInner(); literal?.setSpan(token, token); return literal; } 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(); _consume(TokenType.rightParen, 'Expected a closing bracket'); return Parentheses(left, expr, _previous)..setSpan(left, _previous); } } else if (_matchOne(TokenType.dollarSignVariable)) { if (enableMoorExtensions) { final typedToken = _previous as DollarSignVariableToken; return DartExpressionPlaceholder(name: typedToken.name) ..token = typedToken ..setSpan(_previous, _previous); } } else if (_checkIdentifier()) { final first = _consumeIdentifier( 'This error message should never be displayed. Please report.'); // could be table.column, function(...), cast(...) or just column if (_matchOne(TokenType.dot)) { final second = _consumeIdentifier('Expected a column name here', lenient: true); return Reference( tableName: first.identifier, columnName: second.identifier) ..setSpan(first, second); } else if (_matchOne(TokenType.leftParen)) { if (first.identifier.toLowerCase() == '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 { // regular function invocation final parameters = _functionParameters(); final rightParen = _consume(TokenType.rightParen, 'Expected closing bracket after argument list'); if (_peek.type == TokenType.filter || _peek.type == TokenType.over) { return _aggregate(first, parameters); } return FunctionExpression( name: first.identifier, parameters: parameters) ..setSpan(first, rightParen); } } else { return Reference(columnName: first.identifier)..setSpan(first, first); } } _error('Could not parse this expression'); } @override Variable _variableOrNull() { if (_matchOne(TokenType.questionMarkVariable)) { return NumberedVariable(_previous as QuestionMarkVariableToken) ..setSpan(_previous, _previous); } else if (_matchOne(TokenType.colonVariable)) { return ColonNamedVariable(_previous as ColonVariableToken) ..setSpan(_previous, _previous); } return null; } 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 = _matchOne(TokenType.distinct); final parameters = []; final first = _peek; do { parameters.add(expression()); } while (_matchOne(TokenType.comma)); return ExprFunctionParameters(distinct: distinct, parameters: parameters) ..setSpan(first, _previous); } AggregateExpression _aggregate( IdentifierToken name, FunctionParameters params) { 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'); } _consume(TokenType.over, 'Expected OVER to begin window clause'); String windowName; WindowDefinition window; if (_matchOne(TokenType.identifier)) { windowName = (_previous as IdentifierToken).identifier; } else { window = _windowDefinition(); } return AggregateExpression( function: name, parameters: params, filter: filter, windowDefinition: window, windowName: windowName, )..setSpan(name, _previous); } @override Expression _consumeTuple({bool orSubQuery = 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)..setSpan(firstToken, _previous); } else { _consume(TokenType.rightParen, 'Expected right parenthesis to finish subquery'); return SubQuery(select: subQuery)..setSpan(firstToken, _previous); } } } lib/src/reader/parser/num_parser.dart0000644000175000017500000000047113506466600017646 0ustar00pubpub00000000000000part of 'parser.dart'; /// Parses a number from the [lexeme] assuming it has a form conforming to /// https://www.sqlite.org/syntax/numeric-literal.html num _parseNumber(String lexeme) { if (lexeme.startsWith('0x')) { return int.parse(lexeme.substring(2), radix: 16); } return double.parse(lexeme); } lib/src/reader/parser/parser.dart0000644000175000017500000002702413611657705016777 0ustar00pubpub00000000000000import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; part 'crud.dart'; part 'num_parser.dart'; part 'expressions.dart'; part 'schema.dart'; const _comparisonOperators = [ TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, ]; const _binaryOperators = [ TokenType.shiftLeft, TokenType.shiftRight, TokenType.ampersand, TokenType.pipe, ]; const _startOperators = [ TokenType.natural, TokenType.left, TokenType.inner, TokenType.cross, TokenType.join, ]; class ParsingError implements Exception { final Token token; final String message; ParsingError(this.token, this.message); @override String toString() { return token.span.message('Error: $message}'); } } abstract class ParserBase { final List tokens; final List errors = []; final AutoCompleteEngine autoComplete; /// Whether to enable the extensions moor makes to the sql grammar. final bool enableMoorExtensions; int _current = 0; ParserBase(this.tokens, this.enableMoorExtensions, this.autoComplete); 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((type) => HintDescription.token(type)); 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 => 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; } /// 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; } /// 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; } @alwaysThrows Null _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); } /// 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; } // Common operations that we are referenced very often Expression expression(); List _typeName(); /// Parses a [Tuple]. If [orSubQuery] is set (defaults to false), a [SubQuery] /// (in brackets) will be accepted as well. Expression _consumeTuple({bool orSubQuery = false}); /// 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}); /// 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(); Variable _variableOrNull(); Literal _literalOrNull(); OrderingMode _orderingModeOrNull(); /// https://www.sqlite.org/syntax/window-defn.html WindowDefinition _windowDefinition(); /// Parses a block, which consists of statements between `BEGIN` and `END`. Block _consumeBlock(); /// Skips all tokens until it finds one with [type]. If [skipTarget] is true, /// that token will be skipped as well. /// /// When using `_synchronize(TokenType.semicolon, skipTarget: true)`, /// this will move the parser to the next statement, which can be useful for /// error recovery. void _synchronize(TokenType type, {bool skipTarget = false}) { if (skipTarget) { while (!_isAtEnd && _advance().type != type) {} } else { while (!_isAtEnd && !_check(type)) { _advance(); } } } } class Parser extends ParserBase with ExpressionParser, SchemaParser, CrudParser { Parser(List tokens, {bool useMoor = false, AutoCompleteEngine autoComplete}) : super(tokens, useMoor, autoComplete); // todo remove this and don't be that lazy in moorFile() var _lastStmtHadParsingError = false; Statement statement() { final first = _peek; Statement stmt = _crud(); stmt ??= _create(); if (enableMoorExtensions) { stmt ??= _import() ?? _declaredStatement(); } if (stmt == null) { _error('Expected a sql statement to start here'); } if (_matchOne(TokenType.semicolon)) { stmt.semicolon = _previous; } if (!_isAtEnd) { _error('Expected the statement to finish here'); } return stmt..setSpan(first, _previous); } MoorFile moorFile() { final first = _peek; final foundComponents = []; // (we try again if the last statement had a parsing error) // first, parse import statements for (var stmt = _parseAsStatement(_import); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_import)) { foundComponents.add(stmt); } // next, table declarations for (var stmt = _parseAsStatement(_create); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_create)) { foundComponents.add(stmt); } // finally, declared statements for (var stmt = _parseAsStatement(_declaredStatement); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_declaredStatement)) { foundComponents.add(stmt); } if (!_isAtEnd) { _error('Expected the file to end here.'); } foundComponents.removeWhere((c) => c == null); final file = MoorFile(foundComponents); if (foundComponents.isNotEmpty) { file.setSpan(first, _previous); } else { file.setSpan(first, first); // empty file } return file; } 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 { final first = _peek; final variable = _variableOrNull(); if (variable == null) { _error('Expected a variable here'); } final as = _consume(TokenType.as, 'Expected AS followed by a type'); final typeNameTokens = _typeName(); if (typeNameTokens == null) { _error('Expected a type name here'); } final typeName = typeNameTokens.lexeme; parameters.add(VariableTypeHint(variable, typeName) ..as = as ..setSpan(first, _previous)); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing parenthesis'); } final colon = _consume(TokenType.colon, 'Expected a colon (:) followed by a query'); final stmt = _crud(); if (stmt == null) { _error( 'Expected a sql statement here (SELECT, UPDATE, INSERT or DELETE)'); } return DeclaredStatement( identifier, stmt, parameters: parameters, )..colon = colon; } /// Invokes [parser], sets the appropriate source span and attaches a /// semicolon if one exists. T _parseAsStatement(T Function() parser) { _lastStmtHadParsingError = false; final first = _peek; T result; try { result = parser(); } on ParsingError { _lastStmtHadParsingError = true; // the error is added to the list errors, so ignore. We skip after the // next semicolon to parse the next statement. _synchronize(TokenType.semicolon, skipTarget: true); } if (result == null) return null; if (_matchOne(TokenType.semicolon)) { result.semicolon = _previous; } result.setSpan(first, _previous); return result; } @override Block _consumeBlock() { final begin = _consume(TokenType.begin, 'Expected BEGIN'); final stmts = []; for (var stmt = _parseAsStatement(_crud); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_crud)) { if (stmt != null) stmts.add(stmt); } final end = _consume(TokenType.end, 'Expected END'); return Block(stmts) ..setSpan(begin, end) ..begin = begin ..end = end; } } extension on List { String get lexeme => first.span.expand(last.span).text; } lib/src/reader/parser/schema.dart0000644000175000017500000004630313611657705016744 0ustar00pubpub00000000000000part of 'parser.dart'; mixin SchemaParser on ParserBase { 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(); } return null; } /// 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; do { try { final tableConstraint = _tableConstraintOrNull(); if (tableConstraint != null) { encounteredTableConstraint = true; tableConstraints.add(tableConstraint); } else { if (encounteredTableConstraint) { _error('Expected another table constraint'); } else { columns.add(_columnDefinition()); } } } on ParsingError { // if we're at the closing bracket, don't try to parse another column if (_check(TokenType.rightParen)) break; // error while parsing a column definition or table constraint. We try // to recover to the next comma. _synchronize(TokenType.comma); if (_check(TokenType.rightParen)) break; } } while (_matchOne(TokenType.comma)); final rightParen = _consume(TokenType.rightParen, 'Expected closing parenthesis'); var withoutRowId = false; if (_matchOne(TokenType.without)) { _consume( TokenType.rowid, 'Expected ROWID to complete the WITHOUT ROWID part'); withoutRowId = true; } final overriddenName = _overriddenDataClassName(); return CreateTableStatement( ifNotExists: ifNotExists, tableName: tableIdentifier.identifier, withoutRowId: withoutRowId, columns: columns, tableConstraints: tableConstraints, overriddenDataClassName: overriddenName, ) ..setSpan(first, _previous) ..openingBracket = leftParen ..closingBracket = rightParen ..tableNameToken = tableIdentifier; } /// 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 moorDataClassName = _overriddenDataClassName(); return CreateVirtualTableStatement( ifNotExists: ifNotExists, tableName: nameToken.identifier, moduleName: moduleName.identifier, arguments: args, overriddenDataClassName: moorDataClassName, ) ..setSpan(first, _previous) ..tableNameToken = nameToken ..moduleNameToken = moduleName; } String _overriddenDataClassName() { if (enableMoorExtensions && _matchOne(TokenType.as)) { return _consumeIdentifier('Expected the name for the data class') .identifier; } return null; } /// 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 = const DeleteTarget(); } else if (_matchOne(TokenType.insert)) { target = const InsertTarget(); } else { _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); } _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 [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 = []; do { final expr = expression(); final mode = _orderingModeOrNull(); indexes.add(IndexedColumn(expr, mode)..setSpan(expr.first, _previous)); } while (_matchOne(TokenType.comma)); _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); } /// 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 = _consume(TokenType.identifier, 'Expected a column name') as IdentifierToken; 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; } @override List _typeName() { // 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.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 = _literalOrNull(); // when not a literal, expect an expression in parentheses expr ??= _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 (_peek.type == TokenType.references) { final clause = _foreignKeyClause(); return ForeignKeyColumnConstraint(resolvedName, clause) ..setSpan(first, _previous); } if (enableMoorExtensions && _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 (enableMoorExtensions && _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; } // 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() { 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'); } final columns = _listColumnsInParentheses(allowEmpty: false); final conflictClause = _conflictClauseOrNull(); result = KeyClause(name, isPrimaryKey: isPrimaryKey, indexedColumns: 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) { // 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; } ForeignKeyClause _foreignKeyClause() { // https://www.sqlite.org/syntax/foreign-key-clause.html _consume(TokenType.references, 'Expected REFERENCES'); final firstToken = _previous; final foreignTable = _consumeIdentifier('Expected a table name'); final foreignTableName = TableReference(foreignTable.identifier, null) ..setSpan(foreignTable, foreignTable); 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'); } } return ForeignKeyClause( foreignTable: foreignTableName, columnNames: columnNames, onUpdate: onUpdate, onDelete: onDelete, )..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; } } lib/src/reader/syntactic_entity.dart0000644000175000017500000000216713607160456017602 0ustar00pubpub00000000000000import '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; } lib/src/reader/tokenizer/scanner.dart0000644000175000017500000003035013611657705017646 0ustar00pubpub00000000000000import 'dart:typed_data'; 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 moor. final bool scanMoorTokens; final SourceFile _file; final List tokens = []; final List errors = []; int _startOffset; int _currentOffset = 0; bool get _isAtEnd => _currentOffset >= source.length; FileSpan get _currentSpan { return _file.span(_startOffset, _currentOffset); } SourceLocation get _currentLocation { return _file.location(_currentOffset); } Scanner(this.source, {this.scanMoorTokens = 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)); for (var i = 0; i < tokens.length; i++) { tokens[i].index = i; } return tokens; } void _scanToken() { final char = _nextChar(); switch (char) { case charParenLeft: _addToken(TokenType.leftParen); break; case charParenRight: _addToken(TokenType.rightParen); break; case charComma: _addToken(TokenType.comma); break; case charPeriod: if (!_isAtEnd && isDigit(_peek())) { _numeric(char); } else { _addToken(TokenType.dot); } break; case charPlus: _addToken(TokenType.plus); break; case charMinus: if (_match(charMinus)) { _lineComment(); } else { _addToken(TokenType.minus); } break; case charStar: _addToken(TokenType.star); break; case charSlash: if (_match(charStar)) { _cStyleComment(); } else { _addToken(TokenType.slash); } break; case charPercent: _addToken(TokenType.percent); break; case charAmpersand: _addToken(TokenType.ampersand); break; case charPipe: _addToken(_match(charPipe) ? TokenType.doublePipe : TokenType.pipe); break; case charLess: if (_match(charEquals)) { _addToken(TokenType.lessEqual); } else if (_match(charLess)) { _addToken(TokenType.shiftLeft); } else if (_match(charGreater)) { _addToken(TokenType.lessMore); } else { _addToken(TokenType.less); } break; case charGreater: if (_match(charEquals)) { _addToken(TokenType.moreEqual); } else if (_match(charGreater)) { _addToken(TokenType.shiftRight); } else { _addToken(TokenType.more); } break; case charExclMark: // ! if (_match(charEquals)) { _addToken(TokenType.exclamationEqual); } break; case charEquals: _addToken(_match(charEquals) ? TokenType.doubleEqual : TokenType.equal); break; case charTilde: _addToken(TokenType.tilde); break; case charQuestionMark: // 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 charColon: final name = _matchColumnName(); if (name == null) { _addToken(TokenType.colon); } else { tokens.add(ColonVariableToken(_currentSpan, ':$name')); } break; case charDollarSign: final name = _matchColumnName(); tokens.add(DollarSignVariableToken(_currentSpan, name)); break; case charAt: final name = _matchColumnName(); tokens.add(AtSignVariableToken(_currentSpan, name)); break; case charSemicolon: _addToken(TokenType.semicolon); break; case charCodeX: case charCodeLowerX: if (_match(charSingleTick)) { _string(binary: true); } else { _identifier(); } break; case charSingleTick: _string(); break; case charDoubleTick: _identifier(escapedInQuotes: true); break; case charBacktick: if (scanMoorTokens) { _inlineDart(); } else { _unexpectedToken(); } break; case charSpace: case charCarriageReturn: case charTab: case charLineFeed: // ignore whitespace break; default: if (isDigit(char)) { _numeric(char); } else if (canStartColumnName(char)) { _identifier(); } else { _unexpectedToken(); } break; } } void _unexpectedToken() { errors.add(TokenizerError('Unexpected character.', _currentLocation)); } @pragma('vm:prefer-inline') int _nextChar() { _advance(); return _charCodes[_currentOffset - 1]; } @pragma('vm:prefer-inline') 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) { tokens.add(Token(type, _currentSpan)); } 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 == charSingleTick) { if (!_isAtEnd && _peek() == charSingleTick) { _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 + 1, _currentOffset - 1) .replaceAll("''", "'"); tokens.add(StringLiteralToken(value, _currentSpan, binary: binary)); } void _numeric(int firstChar) { // https://www.sqlite.org/syntax/numeric-literal.html // We basically have three cases: hexadecimal numbers (starting with 0x), // numbers starting with a decimal dot and numbers starting with a digit. if (firstChar == charCodeZero) { if (!_isAtEnd && (_peek() == charCodeLowerX || _peek() == charCodeX)) { _nextChar(); // consume the x // advance hexadecimal digits while (!_isAtEnd && isHexDigit(_peek())) { _nextChar(); } _addToken(TokenType.numberLiteral); return; } } void consumeDigits() { while (!_isAtEnd && isDigit(_peek())) { _nextChar(); } } /// 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; } // ok, we're not dealing with a hexadecimal number. if (firstChar == charPeriod) { // started with a decimal point. the next char has to be numeric if (_requireDigit('Expected a digit after the decimal dot')) { 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; } consumeDigits(); // optional decimal part if (!_isAtEnd && _peek() == charPeriod) { _nextChar(); // if there is a decimal separator, there must be at least one digit // after it if (_requireDigit('Expected a digit after the decimal dot')) { consumeDigits(); } else { return; } } } // 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() == charLowerE || _peek() == charCodeE)) { _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)) { consumeDigits(); _addToken(TokenType.numberLiteral); return; } else { if (char == charPlus || char == charMinus) { _requireDigit('Expected digits for the exponent'); consumeDigits(); _addToken(TokenType.numberLiteral); } else { errors .add(TokenizerError('Expected plus or minus', _currentLocation)); } } } else { // ok, no scientific notation _addToken(TokenType.numberLiteral); } } void _identifier({bool escapedInQuotes = false}) { if (escapedInQuotes) { // find the closing quote while (!_isAtEnd && _peek() != charDoubleTick) { _nextChar(); } // Issue an error if the column name is unterminated if (_isAtEnd) { errors .add(TokenizerError('Unterminated column name', _currentLocation)); } else { // consume the closing double quote _nextChar(); tokens.add(IdentifierToken(true, _currentSpan)); } } else { while (!_isAtEnd && continuesColumnName(_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 (scanMoorTokens && moorKeywords.containsKey(text)) { tokens.add(KeywordToken(moorKeywords[text], _currentSpan)); } else { tokens.add(IdentifierToken(false, _currentSpan)); } } } String _matchColumnName() { if (_isAtEnd || !canStartColumnName(_peek())) return null; final buffer = StringBuffer()..writeCharCode(_nextChar()); while (!_isAtEnd && continuesColumnName(_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() != charBacktick && !_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() != charLineFeed) { 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(charStar)) { if (!_isAtEnd && _match(charSlash)) { break; } else { // write the * we otherwise forgot to write contentBuilder.writeCharCode(charStar); } } else { contentBuilder.writeCharCode(_nextChar()); } } tokens.add(CommentToken( CommentMode.cStyle, contentBuilder.toString(), _currentSpan)); } } lib/src/reader/tokenizer/token.dart0000644000175000017500000002345213611657705017342 0ustar00pubpub00000000000000import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; enum TokenType { leftParen, rightParen, comma, dot, doublePipe, star, slash, percent, plus, minus, shiftLeft, shiftRight, ampersand, pipe, less, lessEqual, more, moreEqual, equal, doubleEqual, exclamationEqual, lessMore, $is, $in, not, like, glob, match, regexp, escape, and, or, tilde, between, exists, collate, questionMarkVariable, colon, colonVariable, atSignVariable, dollarSignVariable, stringLiteral, numberLiteral, $true, $false, $null, isNull, notNull, currentTime, currentDate, currentTimestamp, identifier, select, delete, update, insert, into, distinct, all, from, as, where, natural, left, outer, inner, cross, join, on, using, group, order, by, asc, desc, having, limit, offset, $case, when, then, $else, end, window, filter, over, partition, range, rows, groups, unbounded, preceding, following, current, row, exclude, others, ties, rollback, abort, replace, fail, ignore, set, union, intersect, except, create, virtual, table, trigger, $index, $if, $with, without, rowid, constraint, autoincrement, primary, foreign, key, unique, check, $default, $values, conflict, references, cascade, restrict, no, action, recursive, before, after, instead, of, $for, each, begin, semicolon, comment, eof, /// Moor specific token, used to declare a type converters mapped, inlineDart, import, json, } const Map keywords = { 'SELECT': TokenType.select, 'INSERT': TokenType.insert, 'INTO': TokenType.into, 'COLLATE': TokenType.collate, 'DISTINCT': TokenType.distinct, 'UPDATE': TokenType.update, 'ALL': TokenType.all, 'AND': TokenType.and, 'OR': TokenType.or, 'EXISTS': TokenType.exists, 'BETWEEN': TokenType.between, 'DELETE': TokenType.delete, 'FROM': TokenType.from, 'NATURAL': TokenType.natural, 'LEFT': TokenType.left, 'OUTER': TokenType.outer, 'INNER': TokenType.inner, 'CROSS': TokenType.cross, 'JOIN': TokenType.join, 'ON': TokenType.on, 'USING': TokenType.using, 'AS': TokenType.as, 'WHERE': TokenType.where, 'ORDER': TokenType.order, 'GROUP': TokenType.group, 'HAVING': TokenType.having, 'BY': TokenType.by, 'ASC': TokenType.asc, 'DESC': TokenType.desc, 'LIMIT': TokenType.limit, 'OFFSET': TokenType.offset, 'SET': TokenType.set, 'IS': TokenType.$is, 'IN': TokenType.$in, 'LIKE': TokenType.like, 'GLOB': TokenType.glob, 'MATCH': TokenType.match, 'REGEXP': TokenType.regexp, 'ESCAPE': TokenType.escape, 'NOT': TokenType.not, 'TRUE': TokenType.$true, 'FALSE': TokenType.$false, 'NULL': TokenType.$null, 'ISNULL': TokenType.isNull, 'NOTNULL': TokenType.notNull, 'CURRENT_TIME': TokenType.currentTime, 'CURRENT_DATE': TokenType.currentDate, 'CURRENT_TIMESTAMP': TokenType.currentTimestamp, 'CASE': TokenType.$case, 'WHEN': TokenType.when, 'THEN': TokenType.then, 'ELSE': TokenType.$else, 'END': TokenType.end, 'ABORT': TokenType.abort, 'ROLLBACK': TokenType.rollback, 'REPLACE': TokenType.replace, 'FAIL': TokenType.fail, 'IGNORE': TokenType.ignore, 'CREATE': TokenType.create, 'TABLE': TokenType.table, 'TRIGGER': TokenType.trigger, 'INDEX': TokenType.$index, 'IF': TokenType.$if, 'WITH': TokenType.$with, 'WITHOUT': TokenType.without, 'ROWID': TokenType.rowid, 'CONSTRAINT': TokenType.constraint, 'AUTOINCREMENT': TokenType.autoincrement, 'PRIMARY': TokenType.primary, 'FOREIGN': TokenType.foreign, 'KEY': TokenType.key, 'UNIQUE': TokenType.unique, 'CHECK': TokenType.check, 'DEFAULT': TokenType.$default, 'CONFLICT': TokenType.conflict, 'REFERENCES': TokenType.references, 'CASCADE': TokenType.cascade, 'RESTRICT': TokenType.restrict, 'NO': TokenType.no, 'ACTION': TokenType.action, 'FILTER': TokenType.filter, 'OVER': TokenType.over, 'PARTITION': TokenType.partition, 'RANGE': TokenType.range, 'RECURSIVE': TokenType.recursive, 'ROWS': TokenType.rows, 'GROUPS': TokenType.groups, 'UNBOUNDED': TokenType.unbounded, 'PRECEDING': TokenType.preceding, 'FOLLOWING': TokenType.following, 'CURRENT': TokenType.current, 'ROW': TokenType.row, 'EXCLUDE': TokenType.exclude, 'OTHERS': TokenType.others, 'TIES': TokenType.ties, 'WINDOW': TokenType.window, 'VALUES': TokenType.$values, 'UNION': TokenType.union, 'INTERSECT': TokenType.intersect, 'EXCEPT': TokenType.except, 'BEFORE': TokenType.before, 'AFTER': TokenType.after, 'INSTEAD': TokenType.instead, 'OF': TokenType.of, 'FOR': TokenType.$for, 'EACH': TokenType.each, 'BEGIN': TokenType.begin, 'VIRTUAL': TokenType.virtual, }; /// 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 moorKeywords.entries) entry.value: entry.key, }; const Map moorKeywords = { 'MAPPED': TokenType.mapped, 'IMPORT': TokenType.import, 'JSON': TokenType.json, }; /// 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()); 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. int index; 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(TokenType type, FileSpan span) : super(type, 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 moor /// 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(TokenType type, FileSpan span) : super(type, span); bool canConvertToIdentifier() { // https://stackoverflow.com/a/45775719, but we don't parse indexed yet. return type == TokenType.join || moorKeywords.values.contains(type); } IdentifierToken convertToIdentifier() { isIdentifier = true; return IdentifierToken(false, span, synthetic: false); } } 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 { final String message; final SourceLocation location; TokenizerError(this.message, this.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/utils.dart0000644000175000017500000000366513611657705017366 0ustar00pubpub00000000000000const charTab = 9; // \t const charLineFeed = 10; // \n const charCarriageReturn = 13; // \r const charSpace = 32; const charExclMark = 33; // ! const charDoubleTick = 34; // " const charDollarSign = 36; const charPercent = 37; // % const charAmpersand = 38; // & const charSingleTick = 39; // ' const charParenLeft = 40; // ( const charParenRight = 41; // ) const charStar = 42; // * const charPlus = 43; // + const charComma = 44; // , const charMinus = 45; // - const charPeriod = 46; // . const charSlash = 47; // / const charCodeZero = 48; // '0'.codeUnitAt(0); const charCodeNine = 57; // '9'.codeUnitAt(0); const charColon = 58; // : const charSemicolon = 59; // ; const charLess = 60; // < const charEquals = 61; // = const charGreater = 62; // > const charQuestionMark = 63; // ? const charAt = 64; // @ const charCodeA = 65; // 'A'.codeUnitAt(0); const charCodeE = 69; // E const charCodeF = 70; // 'F'.codeUnitAt(0); const charCodeUnderscore = 95; // '_'.codeUnitAt(0); const charCodeLowerA = 97; // 'a'.codeUnitAt(0); const charCodeLowerF = 102; // 'f'.codeUnitAt(0); const charCodeX = 88; // X const charCodeZ = 90; // 'Z'.codeUnitAt(0); const charBacktick = 96; const charLowerE = 101; const charCodeLowerX = 120; // x const charCodeLowerZ = 122; // 'z'.codeUnitAt(0); const charPipe = 124; // | const charTilde = 126; // ~ bool isDigit(int charCode) { return charCodeZero <= charCode && charCode <= charCodeNine; } bool isHexDigit(int charCode) { return (charCodeLowerA <= charCode && charCode <= charCodeLowerF) || (charCodeA <= charCode && charCode <= charCodeF) || (charCodeZero <= charCode && charCode <= charCodeNine); } bool canStartColumnName(int charCode) { return charCode == charCodeUnderscore || (charCodeLowerA <= charCode && charCode <= charCodeLowerZ) || (charCodeA <= charCode && charCode <= charCodeZ); } bool continuesColumnName(int charCode) { return canStartColumnName(charCode) || isDigit(charCode); } lib/src/utils/ast_equality.dart0000644000175000017500000000134313506466600016600 0ustar00pubpub00000000000000import '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) { if (a.runtimeType != b.runtimeType) { throw ArgumentError('Not equal: First was $a, second $b'); } if (!a.contentEquals(b)) { throw ArgumentError('Content not equal: $a and $b'); } final childrenA = a.childNodes.iterator; final childrenB = b.childNodes.iterator; // always move both iterators while (childrenA.moveNext() & childrenB.moveNext()) { enforceEqual(childrenA.current, childrenB.current); } if (childrenA.moveNext() || childrenB.moveNext()) { throw ArgumentError("$a and $b don't have an equal amount of children"); } } lib/src/utils/meta.dart0000644000175000017500000000141413545361247015025 0ustar00pubpub00000000000000/// 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; } } mono_pkg.yaml0000644000175000017500000000022313527467305013222 0ustar00pubpub00000000000000dart: - stable stages: - analyze: - dartanalyzer: --fatal-infos --fatal-warnings lib/ test/ - dartfmt - unit_test: - test pubspec.yaml0000644000175000017500000000065413611657705013061 0ustar00pubpub00000000000000name: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.6.0 homepage: https://github.com/simolus3/moor/tree/develop/sqlparser #homepage: https://moor.simonbinder.eu/ issue_tracker: https://github.com/simolus3/moor/issues environment: sdk: '>=2.6.0 <3.0.0' dependencies: meta: ^1.1.0 collection: ^1.14.11 source_span: ^1.5.5 dev_dependencies: test: ^1.9.4 path: ^1.6.0test/analysis/column_resolver_test.dart0000644000175000017500000000366013611657705020467 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { final engine = SqlEngine(); 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 old; 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 new; END; '''); expect( context.errors, contains(const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span.text, 'span.text', 'new')), ); }); }); group('insert', () { test('can use NEW references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE INSERT ON demo BEGIN SELECT * FROM new; 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 old; END; '''); expect( context.errors, contains(const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span.text, 'span.text', 'old')), ); }); }); test('update can use NEW and OLD references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE UPDATE ON demo BEGIN SELECT * FROM new; INSERT INTO old VALUES (1, 'foo'); END; '''); expect(context.errors, isEmpty); }); }); } test/analysis/common_table_expressions.dart0000644000175000017500000000323713607160456021310 0ustar00pubpub00000000000000import '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; final types = context.types; expect(select.resolvedColumns.map((c) => c.name), ['foo', 'bar']); expect( select.resolvedColumns.map((c) => types.resolveColumn(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/analysis/data.dart0000644000175000017500000000135613607160456015120 0ustar00pubpub00000000000000import '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, hint: IsDateTime())); final Table anotherTable = Table( name: 'tbl', resolvedColumns: [anotherId, dateTime], ); test/analysis/errors/compound_column_mismatch.dart0000644000175000017500000000073513545361247022613 0ustar00pubpub00000000000000import '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/limit_or_order_by_in_compound_test.dart0000644000175000017500000000203613545361247024655 0ustar00pubpub00000000000000import '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 ORDER BY 3 UNION SELECT 2'); expect(analyzed.errors, hasLength(1)); final error = analyzed.errors.single; expect(error.type, AnalysisErrorType.synctactic); final wrongLimit = (analyzed.root as CompoundSelectStatement).base.orderBy; expect(error.relevantNode, 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 wrongOrderBy = (analyzed.root as CompoundSelectStatement).additional[0].select.orderBy; expect(error.relevantNode, wrongOrderBy); }); } test/analysis/json_functions_test.dart0000644000175000017500000000360713611657705020313 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { group('resolves return types of json functions', () { ResolveResult findResult(String expression) { final engine = SqlEngine.withOptions(EngineOptions(enableJson1: true)); 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)); 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); }); 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/analysis/reference_resolver_test.dart0000644000175000017500000001011713563747057021131 0ustar00pubpub00000000000000import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import '../parser/utils.dart'; import 'data.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[0] as TableReference; expect((firstColumn.expression as Reference).resolved, id); expect((secondColumn.expression as Reference).resolved, content); expect(from.resolved, demoTable); final where = select.where as BinaryExpression; expect((where.left as Reference).resolved, id); }); 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.numberLiteral)), token(TokenType.star), Reference(tableName: 'd', columnName: 'id'), ), ); }); 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']); }); }); test('resolves sub-queries', () { 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('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 AggregateExpression).over; enforceEqual( over, WindowDefinition( partitionBy: [Reference(columnName: 'content')], frameSpec: FrameSpec( type: FrameType.groups, start: const FrameBoundary.currentRow(), excludeMode: ExcludeMode.ties, ), ), ); }); } test/analysis/schema/column_test.dart0000644000175000017500000000167613563747057020021 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('isAliasForRowId', () { final engine = SqlEngine(); final 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.dart0000644000175000017500000000514213611657705022143 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../../common_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() { test('affinity from typename', () { final resolver = SchemaFromCreateTable(); _affinityTests.forEach((key, value) { expect(resolver.columnAffinity(key), equals(value), reason: '$key should have $value affinity'); }); }); test('export table structure', () { final engine = SqlEngine(); final stmt = engine.parse(createTableStmt).rootNode; final table = 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('supports booleans when moor extensions are enabled', () { final engine = SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)); final stmt = engine.parse(''' CREATE TABLE foo ( a BOOL, b DATETIME, c DATE, d BOOLEAN NOT NULL ) ''').rootNode; final table = SchemaFromCreateTable(moorExtensions: true) .read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int, hint: IsBoolean(), nullable: true), ResolvedType(type: BasicType.int, hint: IsDateTime(), nullable: true), ResolvedType(type: BasicType.int, hint: IsDateTime(), nullable: true), ResolvedType(type: BasicType.int, hint: IsBoolean(), nullable: false), ]); }); } test/analysis/schema/table_test.dart0000644000175000017500000000215413607160456017572 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { group('finds columns', () { final engine = SqlEngine(); final 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/types/resolver_test.dart0000644000175000017500000001022013611657705020244 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; Map _types = { 'SELECT * FROM demo WHERE id = ?': const ResolveResult(ResolvedType(type: BasicType.int)), 'SELECT * FROM demo WHERE content = ?': const ResolveResult(ResolvedType(type: BasicType.text)), 'SELECT * FROM demo LIMIT ?': const ResolveResult(ResolvedType(type: BasicType.int)), 'SELECT 1 FROM demo GROUP BY id HAVING COUNT(*) = ?': const ResolveResult(ResolvedType(type: BasicType.int)), 'SELECT 1 FROM demo WHERE id BETWEEN 3 AND ?': const ResolveResult(ResolvedType(type: BasicType.int)), 'UPDATE demo SET content = ? WHERE id = 3': const ResolveResult(ResolvedType(type: BasicType.text)), 'SELECT * FROM demo WHERE content LIKE ?': const ResolveResult(ResolvedType(type: BasicType.text)), "SELECT * FROM demo WHERE content LIKE '%e' ESCAPE ?": const ResolveResult(ResolvedType(type: BasicType.text)), 'SELECT * FROM demo WHERE content IN ?': const ResolveResult(ResolvedType(type: BasicType.text, isArray: true)), 'SELECT * FROM demo WHERE content IN (?)': const ResolveResult(ResolvedType(type: BasicType.text, isArray: false)), 'SELECT * FROM demo JOIN tbl ON demo.id = tbl.id WHERE date = ?': const ResolveResult( ResolvedType(type: BasicType.int, hint: IsDateTime())), 'SELECT row_number() OVER (RANGE ? PRECEDING)': const ResolveResult(ResolvedType(type: BasicType.int)), 'SELECT ?;': const ResolveResult.unknown(), 'SELECT CAST(3 AS TEXT) = ?': const ResolveResult(ResolvedType(type: BasicType.text)), 'SELECT (3 * 4) = ?': const ResolveResult(ResolvedType(type: BasicType.int)), 'SELECT (3 / 4) = ?': const ResolveResult(ResolvedType(type: BasicType.int)), }; void main() { _types.forEach((sql, resolvedType) { test('types: resolves in $sql', () { final engine = SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); final content = engine.analyze(sql); final variable = content.root.allDescendants .firstWhere((node) => node is Variable) as Typeable; expect(content.typeOf(variable), equals(resolvedType)); }); }); test('handles VALUES clause in insert statements', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('INSERT INTO demo VALUES (?, ?), (?, ?)'); final variables = context.root.allDescendants.whereType().toList(); expect(context.typeOf(variables[0]), ResolveResult(id.type)); expect(context.typeOf(variables[1]), ResolveResult(content.type)); expect(context.typeOf(variables[2]), ResolveResult(id.type)); expect(context.typeOf(variables[3]), ResolveResult(content.type)); }); test('handles nth_value', () { final ctx = SqlEngine().analyze("SELECT nth_value('string', ?1) = ?2"); final variables = ctx.root.allDescendants.whereType().iterator; variables.moveNext(); final firstVar = variables.current; variables.moveNext(); final secondVar = variables.current; expect(ctx.typeOf(firstVar), equals(const ResolveResult(ResolvedType(type: BasicType.int)))); expect(ctx.typeOf(secondVar), equals(const ResolveResult(ResolvedType(type: BasicType.text)))); }); test('can infer types for dart placeholder', () { final ctx = (SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)) ..registerTable(demoTable)) .analyze(r'SELECT * FROM demo WHERE $expr'); final dartExpr = ctx.root.allDescendants.whereType().single; expect(ctx.typeOf(dartExpr as Expression), const ResolveResult(ResolvedType.bool())); }); test('respects explicit types for variables', () { final ctx = SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)).analyze( 'SELECT ?', stmtOptions: const AnalyzeStatementOptions(indexedVariableTypes: { 1: ResolvedType.bool(), }), ); final variable = ctx.root.allDescendants.whereType().single; expect(ctx.typeOf(variable), const ResolveResult(ResolvedType.bool())); }); } test/analysis/types2/graph_test.dart0000644000175000017500000000103613611657705017573 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types2/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/types2/misc_cases_test.dart0000644000175000017500000000502313611657705020603 0ustar00pubpub00000000000000import '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 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 (?)': ResolvedType(type: BasicType.text, isArray: false), 'SELECT * FROM demo JOIN tbl ON demo.id = tbl.id WHERE date = ?': ResolvedType(type: BasicType.int, hint: 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), }; SqlEngine _spawnEngine() { return SqlEngine.withOptions( EngineOptions(enableExperimentalTypeInference: true)) ..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/analysis/types2/resolver_test.dart0000644000175000017500000002043013611657705020332 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart' hide TypeResolver; import 'package:sqlparser/src/analysis/types2/types.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { final engine = SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)) ..registerTable(demoTable) ..registerTable(anotherTable); TypeResolver _obtainResolver(String sql, {AnalyzeStatementOptions options}) { final context = engine.analyze(sql, stmtOptions: options); return TypeResolver(TypeInferenceSession(context))..run(context.root); } ResolvedType _resolveFirstVariable(String sql, {AnalyzeStatementOptions options}) { final resolver = _obtainResolver(sql, options: options); final session = resolver.session; final variable = session.context.root.allDescendants.whereType().first; return session.typeOf(variable); } 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('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)); }); test('handles 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 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('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('infers offsets in frame specs', () { final type = _resolveFirstVariable('SELECT SUM(id) OVER (ROWS ? PRECEDING)'); expect(type, const ResolvedType(type: BasicType.int)); }); 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/analysis/variable_indexing_test.dart0000644000175000017500000000147013545361247020717 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.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/common_data.dart0000644000175000017500000000101113527467305014635 0ustar00pubpub00000000000000const 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 COLLATE BINARY REFERENCES some(thing) ON UPDATE CASCADE ON DELETE SET NULL, UNIQUE (score, display_name) ON CONFLICT ABORT, FOREIGN KEY (id, email) REFERENCES another (a, b) ON DELETE NO ACTION ON UPDATE RESTRICT ) '''; test/engine/autocomplete/static_test.dart0000644000175000017500000000226113611657705020657 0ustar00pubpub00000000000000import '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/table_name_test.dart0000644000175000017500000000237313611657705021463 0ustar00pubpub00000000000000import '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 triger', () { final suggestion = _compute('CREATE TRIGGER name BEFORE DELETE ON ^'); expect(suggestion, suggestsTables); }); }); } ComputedSuggestions _compute(String moorFile) { return completionsFor(moorFile, setup: _setupEngine); } void _setupEngine(SqlEngine engine) { engine..registerTable(demoTable)..registerTable(anotherTable); } Matcher get suggestsTables => suggestsAll(['demo', 'tbl', 'sqlite_master']); test/engine/autocomplete/utils.dart0000644000175000017500000000313113611657705017466 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; /// Parses the [moorFile] and computes available autocomplete suggestions at /// the position of a `^` character in the source. ComputedSuggestions completionsFor(String moorFile, {void Function(SqlEngine) setup}) { final position = moorFile.indexOf('^'); final engine = SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)); setup?.call(engine); final result = engine.parseMoorFile(moorFile.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/find_node_by_position_test.dart0000644000175000017500000000133113545361247021226 0ustar00pubpub00000000000000import '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/module/fts5_test.dart0000644000175000017500000001275213611657705017043 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; final _fts5Options = EngineOptions(enabledExtensions: const [Fts5Extension()]); void main() { group('creating fts5 tables', () { final engine = SqlEngine.withOptions(_fts5Options); test('can create fts5 tables', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii')"); final table = SchemaFromCreateTable().read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(1)); expect(columns.single.name, 'bar'); }); test('handles the UNINDEXED column option', () { final result = engine .analyze('CREATE VIRTUAL TABLE foo USING fts5(bar, baz UNINDEXED)'); final table = 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', () { SqlEngine engine; setUp(() { engine = SqlEngine.withOptions(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(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 \'\''); 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))); }); test('return type of highlight()', () { final result = engine.analyze("SELECT *, highlight(foo, 0, '', '') AS b " "FROM foo WHERE foo MATCH ''"); 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 ''"); 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', () { SqlEngine engine; setUp(() { engine = SqlEngine.withOptions(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); void checkVarTypes(String sql, List expected) { final result = engine.analyze(sql); 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 ], ); }); }); group('error reporting', () { SqlEngine engine; setUp(() { engine = SqlEngine.withOptions(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); final normalResult = engine.analyze('CREATE TABLE other (bar TEXT);'); engine.registerTable(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/parser/create_index_test.dart0000644000175000017500000000361013611657705017347 0ustar00pubpub00000000000000import '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.withTrue(token(TokenType.$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/create_table_test.dart0000644000175000017500000001321613607160456017327 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/ast/ast.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, token(TokenType.numberLiteral))), CheckColumn( null, BinaryExpression( Reference(columnName: 'score'), token(TokenType.more), NumericLiteral( 0, token(TokenType.numberLiteral), ), ), ), ], ), ColumnDefinition( columnName: 'display_name', typeName: 'VARCHAR', constraints: [ CollateConstraint( null, 'BINARY', ), ForeignKeyColumnConstraint( null, ForeignKeyClause( foreignTable: TableReference('some', null), columnNames: [Reference(columnName: 'thing')], onUpdate: ReferenceAction.cascade, onDelete: ReferenceAction.setNull, ), ), ], ) ], tableConstraints: [ KeyClause( null, isPrimaryKey: false, indexedColumns: [ Reference(columnName: 'score'), Reference(columnName: 'display_name'), ], onConflict: ConflictClause.abort, ), ForeignKeyTableConstraint( null, columns: [ Reference(columnName: 'id'), Reference(columnName: 'email'), ], clause: ForeignKeyClause( foreignTable: TableReference('another', null), columnNames: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], onDelete: ReferenceAction.noAction, onUpdate: ReferenceAction.restrict, ), ) ], ), ); }); test('parses MAPPED BY constraints when in moor 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), ], ), ]), moorMode: true, ); }); test('parses JSON KEY constraints in moor 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'), ), ], ), ], ), moorMode: true, ); }); test('parses CREATE VIRTUAL TABLE statement', () { testStatement( 'CREATE VIRTUAL TABLE IF NOT EXISTS foo USING bar(a, b(), c) AS moor', CreateVirtualTableStatement( ifNotExists: true, tableName: 'foo', moduleName: 'bar', arguments: [ fakeSpan('a'), fakeSpan('b()'), fakeSpan('c'), ], overriddenDataClassName: 'moor', ), moorMode: 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,)'), throwsA( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at closing bracket', ')'), ), ); expect( () => engine.parse('CREATE VIRTUAL TABLE foo USING bar(a,,b)'), throwsA( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at next comma', ','), ), ); }); } test/parser/create_trigger_test.dart0000644000175000017500000000423513611657705017707 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; final _block = Block([ UpdateStatement(table: TableReference('tbl'), set: [ SetComponent( 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: const 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: const InsertTarget(), onTable: TableReference('tbl'), when: IsExpression( false, Reference(tableName: 'new', columnName: 'foo'), NullLiteral(token(TokenType.$null)), ), action: _block, ), ); }); } test/parser/delete_test.dart0000644000175000017500000000107713527467305016165 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'utils.dart'; void main() { test('parses delete statements', () { testStatement( 'DELETE FROM tbl WHERE id = 5', DeleteStatement( from: TableReference('tbl', null), where: BinaryExpression( Reference(columnName: 'id'), token(TokenType.equal), NumericLiteral( 5, token(TokenType.numberLiteral), ), ), ), ); }); } test/parser/expression_test.dart0000644000175000017500000001177213611657705017124 0ustar00pubpub00000000000000import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/reader/parser/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.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.numberLiteral)), token(TokenType.star), NumericLiteral(7, token(TokenType.numberLiteral)), ), token(TokenType.plus), NumericLiteral(1, token(TokenType.numberLiteral)), ), lower: NumericLiteral(31, token(TokenType.numberLiteral)), upper: NumericLiteral(74, token(TokenType.numberLiteral)), ), '3 * 4 + 5 == COUNT(*)': BinaryExpression( BinaryExpression( BinaryExpression( NumericLiteral(3, token(TokenType.numberLiteral)), token(TokenType.star), NumericLiteral(4, token(TokenType.numberLiteral)), ), token(TokenType.plus), NumericLiteral(5, token(TokenType.numberLiteral)), ), token(TokenType.doubleEqual), FunctionExpression( name: 'COUNT', parameters: StarFunctionParameter(), ), ), '? * ?3 + ?2 == :test': BinaryExpression( BinaryExpression( BinaryExpression( NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), token(TokenType.star), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?3'), 3)), ), token(TokenType.plus), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?2'), 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'), ), "x NOT LIKE '%A%\$' ESCAPE '\$'": StringComparisonExpression( not: true, left: Reference(columnName: 'x'), operator: token(TokenType.like), right: StringLiteral.from(token(TokenType.stringLiteral), '%A%\$'), escape: StringLiteral.from(token(TokenType.stringLiteral), '\$'), ), 'NOT EXISTS (SELECT * FROM demo)': UnaryExpression( token(TokenType.not), ExistsExpression( select: SelectStatement( columns: [StarResultColumn(null)], from: [ TableReference('demo', null), ], ), ), ), '(SELECT x)': SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'x'), ), ], ), ), "'hello' || 'world' COLLATE NOCASE": BinaryExpression( StringLiteral.from(token(TokenType.stringLiteral), 'hello'), token(TokenType.doublePipe), CollateExpression( operator: token(TokenType.collate), inner: StringLiteral.from(token(TokenType.stringLiteral), 'world'), collateFunction: token(TokenType.identifier), ), ), 'x in ?': InExpression( left: Reference(columnName: 'x'), inside: NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), 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', null), ], ), ), ), 'x IN (1, 2, (SELECT 3))': InExpression( left: Reference(columnName: 'x'), inside: Tuple( expressions: [ NumericLiteral(1.0, token(TokenType.numberLiteral)), NumericLiteral(2.0, token(TokenType.numberLiteral)), SubQuery( select: SelectStatement(columns: [ ExpressionResultColumn( expression: NumericLiteral(3.0, token(TokenType.numberLiteral)), ), ]), ), ], ), ), 'CAST(3 + 4 AS TEXT)': CastExpression( BinaryExpression( NumericLiteral(3.0, token(TokenType.numberLiteral)), token(TokenType.plus), NumericLiteral(4.0, token(TokenType.numberLiteral)), ), 'TEXT', ), 'foo ISNULL': IsNullExpression(Reference(columnName: 'foo')), 'foo NOTNULL': IsNullExpression(Reference(columnName: 'foo'), 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.dart0000644000175000017500000000342313545361247017206 0ustar00pubpub00000000000000import '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', null)], limit: DartLimitPlaceholder(name: 'limit'), ), moorMode: true, ); }); test('parses limit count as expressions', () { testStatement( r'SELECT * FROM tbl LIMIT $amount OFFSET 3', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], limit: Limit( count: DartExpressionPlaceholder(name: 'amount'), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(3, token(TokenType.numberLiteral)), ), ), moorMode: 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', null)], orderBy: OrderBy( terms: [ DartOrderingTermPlaceholder(name: 'term'), OrderingTerm( expression: DartExpressionPlaceholder(name: 'expr'), orderingMode: OrderingMode.descending, ), ], ), ), moorMode: true, ); }); test('parses full order by placeholders', () { testStatement( r'SELECT * FROM tbl ORDER BY $order', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], orderBy: DartOrderByPlaceholder(name: 'order'), ), moorMode: true, ); }); } test/parser/insert_test.dart0000644000175000017500000000272113545361247016222 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.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', null), 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', null), targetColumns: const [], source: const DefaultValues(), ), ); }); test('insert statement with select as source', () { testStatement( 'REPLACE INTO tbl SELECT * FROM tbl', InsertStatement( mode: InsertMode.replace, table: TableReference('tbl', null), targetColumns: const [], source: SelectInsertSource( SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ), ); }); } test/parser/moor_file_test.dart0000644000175000017500000000621213611657705016671 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; const content = r''' import 'other.dart'; import 'another.moor'; CREATE TABLE tbl ( id INT NOT NULL PRIMARY KEY AUTOINCREMENT, -- this is a single-line comment place VARCHAR REFERENCES other(location) ) AS RowName all: SELECT /* COUNT(*), */ * FROM tbl WHERE $predicate; @special: SELECT * FROM tbl; typeHints(:foo AS TEXT): SELECT :foo; '''; void main() { test('parses moor files', () { testMoorFile( content, MoorFile([ ImportStatement('other.dart'), ImportStatement('another.moor'), 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', null), columnNames: [ Reference(columnName: 'location'), ], ), ), ], ), ], overriddenDataClassName: 'RowName', ), DeclaredStatement( SimpleName('all'), SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], where: DartExpressionPlaceholder(name: 'predicate'), ), ), DeclaredStatement( SpecialStatementIdentifier('special'), SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), DeclaredStatement( SimpleName('typeHints'), SelectStatement(columns: [ ExpressionResultColumn( expression: ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), ), ]), parameters: [ VariableTypeHint( ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), 'TEXT', ) ], ), ]), ); }); test("reports error when the statement can't be parsed", () { // regression test for https://github.com/simolus3/moor/issues/280#issuecomment-570789454 final parsed = SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)) .parseMoorFile('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 MoorFile; expect( root.allDescendants, isNot(contains(const TypeMatcher())), ); }); } test/parser/multiple_statements.dart0000644000175000017500000000456013607160456017762 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser/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;'; testMoorFile( sql, MoorFile([ DeclaredStatement( SimpleName('a'), UpdateStatement( table: TableReference('tbl', null), set: [ SetComponent( column: Reference(columnName: 'a'), expression: Reference(columnName: 'b'), ), ], ), ), DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ]), ); }); 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).moorFile().statements; expect(statements, hasLength(1)); enforceEqual( statements[0], DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ); }); test('parses imports and declared statements in moor mode', () { const sql = r''' import 'test.dart'; query: SELECT * FROM tbl; '''; final tokens = Scanner(sql, scanMoorTokens: true).scanTokens(); final statements = Parser(tokens, useMoor: true).moorFile().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', null)], ), ), ); }); } test/parser/partition_test.dart0000644000175000017500000000432413611657705016731 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser/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)': AggregateExpression( 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)': AggregateExpression( function: identifier('row_number'), parameters: StarFunctionParameter(), filter: NumericLiteral(1, token(TokenType.numberLiteral)), windowDefinition: WindowDefinition( baseWindowName: 'base_name', partitionBy: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], frameSpec: FrameSpec( type: FrameType.groups, start: const FrameBoundary.unboundedPreceding(), end: FrameBoundary.following( NumericLiteral(3, token(TokenType.numberLiteral)), ), excludeMode: ExcludeMode.ties, ), ), ), 'row_number() OVER (RANGE CURRENT ROW EXCLUDE NO OTHERS)': AggregateExpression( function: identifier('row_number'), parameters: ExprFunctionParameters(), windowDefinition: WindowDefinition( frameSpec: FrameSpec( type: FrameType.range, start: const FrameBoundary.currentRow(), end: const FrameBoundary.currentRow(), excludeMode: ExcludeMode.noOthers, ), ), ), }; 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/recovery_test.dart0000644000175000017500000000337213611657705016560 0ustar00pubpub00000000000000import '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 = parseMoor(''' import ; CREATE TABLE foo (name TEXT); '''); expect( file.childNodes, contains(const TypeMatcher())); }); test('recovers from parsing errors in column definition', () { final file = parseMoor(''' 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.withOptions(EngineOptions(useMoorExtensions: true)); final result = engine.parseMoorFile(''' 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/parser/select/common_table_expression_test.dart0000644000175000017500000000404213602453413023100 0ustar00pubpub00000000000000import '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, token(TokenType.numberLiteral), ), ), ], ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: BinaryExpression( Reference(columnName: 'x'), token(TokenType.plus), NumericLiteral(1, token(TokenType.numberLiteral)), ), ), ], from: [TableReference('cnt')], limit: Limit( count: NumericLiteral( 1000000, token(TokenType.numberLiteral), ), ), ), ), ], ), ), ], ), columns: [ ExpressionResultColumn(expression: Reference(columnName: 'x')), ], from: [TableReference('cnt')], ), ); }); } test/parser/select/compound_test.dart0000644000175000017500000000213213545361247020015 0ustar00pubpub00000000000000import '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', null)], ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(1, token(TokenType.numberLiteral)), ), ], ), ), CompoundSelectPart( mode: CompoundSelectMode.except, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(2, token(TokenType.numberLiteral)), ), ], ), ), ], ), ); }); } test/parser/select/from_test.dart0000644000175000017500000000470513602453413017133 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import '../utils.dart'; void _enforceFrom(SelectStatement stmt, List expected) { enforceHasSpan(stmt); expect(stmt.from.length, expected.length); for (var i = 0; i < stmt.from.length; i++) { enforceEqual(stmt.from[i], expected[i]); } } void main() { group('from', () { test('a simple table', () { final stmt = SqlEngine().parse('SELECT * FROM tbl').rootNode as SelectStatement; enforceEqual(stmt.from.single, TableReference('tbl', null)); }); test('from more than one table', () { final stmt = SqlEngine() .parse('SELECT * FROM tbl AS test, table2') .rootNode as SelectStatement; _enforceFrom( stmt, [ TableReference('tbl', 'test'), TableReference('table2', null), ], ); }); test('from inner select statements', () { final stmt = SqlEngine() .parse( 'SELECT * FROM table1, (SELECT * FROM table2 WHERE a) as "inner"') .rootNode as SelectStatement; _enforceFrom( stmt, [ TableReference('table1', null), SelectStatementAsSource( statement: SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('table2', null)], where: Reference(columnName: 'a'), ), as: 'inner', ), ], ); }); 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', null), joins: [ Join( operator: JoinOperator.inner, query: TableReference('table2', null), constraint: UsingConstraint(columnNames: ['test']), ), Join( operator: JoinOperator.leftOuter, query: TableReference('table3', null), constraint: OnConstraint( expression: BooleanLiteral.withTrue(token(TokenType.$true)), ), ), ], ), ]); }); }); } test/parser/select/generic_test.dart0000644000175000017500000000302313545361247017605 0ustar00pubpub00000000000000import 'package:sqlparser/src/ast/ast.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, token(TokenType.numberLiteral)), as: 'name', ), ], where: NumericLiteral(1, token(TokenType.numberLiteral)), orderBy: OrderBy(terms: [ OrderingTerm( expression: Reference(columnName: 'name'), orderingMode: OrderingMode.ascending, ), ]), limit: Limit( count: NumericLiteral(3, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(5, token(TokenType.numberLiteral)), ), ), 'SELECT tbl.*, (SELECT * FROM table2) FROM tbl': SelectStatement( columns: [ StarResultColumn('tbl'), ExpressionResultColumn( expression: SubQuery( select: SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('table2', null)], ), ), ), ], from: [ TableReference('tbl', null), ], ), 'SELECT * FROM tbl WHERE id IN ()': SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], where: InExpression( left: Reference(columnName: 'id'), inside: Tuple(expressions: []), ), ), }; void main() { testAll(testCases); } test/parser/select/group_by_test.dart0000644000175000017500000000144413602453413020013 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.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.from(token(TokenType.stringLiteral), '%G%'), ), ), ); }); } test/parser/select/limit_test.dart0000644000175000017500000000341713602453413017305 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.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.numberLiteral)), token(TokenType.star), NumericLiteral(3, token(TokenType.numberLiteral)), ), ), ); }); 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, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(2, token(TokenType.numberLiteral)), ), ); }); 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, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.comma), offset: NumericLiteral(10, token(TokenType.numberLiteral)), ), ); }); }); } test/parser/select/order_by_test.dart0000644000175000017500000000151513602453413017771 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.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/parser/update_test.dart0000644000175000017500000000127313607160456016177 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.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', null), set: [ SetComponent( column: Reference(columnName: 'a'), expression: NullLiteral( token(TokenType.$null), ), ), SetComponent( column: Reference(columnName: 'b'), expression: Reference(columnName: 'c'), ) ], where: Reference(columnName: 'd'), ), }; void main() { group('update statements', () { testAll(testCases); }); } test/parser/utils.dart0000644000175000017500000000336213611657705015022 0ustar00pubpub00000000000000import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; export 'package:sqlparser/src/reader/tokenizer/token.dart'; Token token(TokenType type) { return Token(type, null); } InlineDartToken inlineDart(String dartCode) { return InlineDartToken(fakeSpan('`$dartCode`')); } IdentifierToken identifier(String content) { return IdentifierToken(false, fakeSpan(content)); } MoorFile parseMoor(String content) { return SqlEngine.withOptions(EngineOptions(useMoorExtensions: true)) .parseMoorFile(content) .rootNode as MoorFile; } void testMoorFile(String moorFile, MoorFile expected) { final parsed = parseMoor(moorFile); enforceHasSpan(parsed); enforceEqual(parsed, expected); } void testStatement(String sql, AstNode expected, {bool moorMode = false}) { final parsed = SqlEngine.withOptions(EngineOptions(useMoorExtensions: moorMode)) .parse(sql) .rootNode; enforceHasSpan(parsed); enforceEqual(parsed, expected); } 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).firstWhere( (node) => !node.hasSpan && !node.synthetic, orElse: () => null); if (problematic != null) { throw ArgumentError('Node $problematic did not have a span'); } } test/scanner/comments_test.dart0000644000175000017500000000176513545361247016707 0ustar00pubpub00000000000000import '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/scanner/moor_tokens_test.dart0000644000175000017500000000143113607160456017405 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; void main() { test('parses moor specific tokens', () { const part = 'c INTEGER MAPPED BY `const Mapper()` NOT NULL'; final scanner = Scanner(part, scanMoorTokens: 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.eof, ]); expect( tokens.whereType().single.dartCode, 'const Mapper()'); }); } test/scanner/single_token_tests.dart0000644000175000017500000000437413611657705017726 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.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, }; void main() { test('parses single tokens', () { testCases.forEach(expectFullToken); }); 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"); scanner.scanTokens(); expect( scanner.errors, contains(const TypeMatcher() .having((e) => e.message, 'message', 'Unterminated string')), ); }); } test/scanner/utils_test.dart0000644000175000017500000000521313611657705016213 0ustar00pubpub00000000000000import 'package:sqlparser/src/reader/tokenizer/utils.dart'; import 'package:test/test.dart'; void main() { test('declared char constants are correct', () { const expected = { charTab: '\t', charLineFeed: '\n', charCarriageReturn: '\r', charSpace: ' ', charExclMark: '!', charDoubleTick: '"', charDollarSign: r'$', charPercent: '%', charAmpersand: '&', charSingleTick: "'", charParenLeft: '(', charParenRight: ')', charStar: '*', charPlus: '+', charComma: ',', charMinus: '-', charPeriod: '.', charSlash: '/', charCodeZero: '0', charCodeNine: '9', charColon: ':', charSemicolon: ';', charLess: '<', charEquals: '=', charGreater: '>', charQuestionMark: '?', charAt: '@', charCodeA: 'A', charCodeE: 'E', charCodeUnderscore: '_', charCodeLowerA: 'a', charCodeLowerF: 'f', charCodeF: 'F', charCodeX: 'X', charCodeZ: 'Z', charBacktick: '`', charLowerE: 'e', charCodeLowerX: 'x', charCodeLowerZ: 'z', charPipe: '|', charTilde: '~', }; for (final testCase in expected.entries) { expect(testCase.key, testCase.value.codeUnitAt(0)); } }); 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('canStartColumnName', () { expect(canStartColumnName('_'.codeUnitAt(0)), isTrue); expect(canStartColumnName('a'.codeUnitAt(0)), isTrue); expect(canStartColumnName('Z'.codeUnitAt(0)), isTrue); expect(canStartColumnName('['.codeUnitAt(0)), isFalse); expect(canStartColumnName('0'.codeUnitAt(0)), isFalse); }); test('continuesColumnName', () { expect(continuesColumnName('_'.codeUnitAt(0)), isTrue); expect(continuesColumnName('a'.codeUnitAt(0)), isTrue); expect(continuesColumnName('Z'.codeUnitAt(0)), isTrue); expect(continuesColumnName('0'.codeUnitAt(0)), isTrue); expect(continuesColumnName('['.codeUnitAt(0)), isFalse); }); }