.gitignore0000644000175000017500000000037213527467305012522 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.jsonCHANGELOG.md0000644000175000017500000000177013545361247012344 0ustar00pubpub00000000000000## 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.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.md0000644000175000017500000000654413545361247012016 0ustar00pubpub00000000000000# sqlparser Sql parser and static analyzer written in Dart. At the moment, this library targets the sqlite dialect only. ## Features This library can parse most sql statements and perform 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 features, including joins, `group by`, nested and compound sql statements, window functions and foreign keys. ### Using the parser You can parse the abstract syntax tree of sqlite statements with `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. - Common table expressions are not supported - Some advanced expressions, like `CAST`s aren't supported yet. - 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.yaml0000777000175000017500000000000013506466600021476 2../analysis_options.yamlustar00pubpub00000000000000example/sqlparser_example.dart0000644000175000017500000000357413507167165016576 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 '''); for (var error in result.errors) { print(error); } final select = result.root as SelectStatement; final columns = select.resolvedColumns; print('the query returns ${columns.length} columns'); for (var 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.dart0000644000175000017500000000042413545361247014164 0ustar00pubpub00000000000000/// An sql parser and analyzer for Dart. library sqlparser; export 'src/analysis/analysis.dart'; export 'src/ast/ast.dart'; export 'src/engine/sql_engine.dart'; export 'src/reader/parser/parser.dart' show ParsingError; export 'src/reader/tokenizer/token.dart' hide keywords; lib/src/analysis/analysis.dart0000644000175000017500000000125713545361247016412 0ustar00pubpub00000000000000import 'dart:math' show min, max; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/utils/meta.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/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 'error.dart'; part 'context.dart'; lib/src/analysis/context.dart0000644000175000017500000000267613545361247016261 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; /// 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. final TypeResolver types = TypeResolver(); /// Constructs a new analysis context from the AST and the source sql. AnalysisContext(this.root, this.sql); /// 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) => 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.dart0000644000175000017500000000314313545361247015714 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, other, } lib/src/analysis/schema/column.dart0000644000175000017500000000317713545361247017327 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 { /// The name of this column in the result set. String get name; Column(); } /// 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. /// /// 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; /// The table this column belongs to. Table table; TableColumn(this.name, this.type, {this.definition}); } /// 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}); } /// The result column of a [CompoundSelectStatement]. class CompoundSelectColumn extends Column { /// The column in [CompoundSelectStatement.base] each of the /// [CompoundSelectStatement.additional] that contributed to this column. final List columns; CompoundSelectColumn(this.columns); @override String get name => columns.first.name; } lib/src/analysis/schema/from_create_table.dart0000644000175000017500000000264713545361247021470 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Reads the [Table] definition from a [CreateTableStatement]. class SchemaFromCreateTable { Table read(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 affinity = columnAffinity(definition.typeName); final nullable = !definition.constraints.any((c) => c is NotNull); final resolvedType = ResolvedType(type: affinity, nullable: nullable); return TableColumn( definition.columnName, resolvedType, definition: definition, ); } /// 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) { if (typeName == null) { return BasicType.blob; } final upper = typeName.toUpperCase(); if (upper.contains('INT')) { return BasicType.int; } if (upper.contains('CHAR') || upper.contains('CLOB') || upper.contains('TEXT')) { return BasicType.text; } if (upper.contains('BLOB')) { return BasicType.blob; } return BasicType.real; } } lib/src/analysis/schema/references.dart0000644000175000017500000000646013545361247020151 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); } /// 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.dart0000644000175000017500000000306013545361247017110 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Something that will resolve to an [ResultSet] when referred to via /// the [ReferenceScope]. abstract class ResolvesToResultSet with Referencable { ResultSet get resultSet; } /// Something that returns a set of columns when evaluated. abstract 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 { /// The name of this table, as it appears in sql statements. This should be /// the raw name, not an escaped version. final String name; @override final List resolvedColumns; /// 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 CreateTableStatement definition; /// Constructs a table from the known [name] and [resolvedColumns]. Table( {@required this.name, this.resolvedColumns, this.withoutRowId = false, this.tableConstraints = const [], this.definition}) { for (var column in resolvedColumns) { column.table = this; } } } lib/src/analysis/steps/column_resolver.dart0000644000175000017500000001320613545361247021140 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) { _resolveSelect(e); visitChildren(e); } @override void visitCompoundSelectStatement(CompoundSelectStatement e) { // first, visit all children so that the compound parts have their columns // resolved visitChildren(e); 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 visitUpdateStatement(UpdateStatement e) { final table = _resolveTableReference(e.table); e.scope.availableColumns = table.resolvedColumns; visitChildren(e); } @override void visitInsertStatement(InsertStatement e) { final table = _resolveTableReference(e.table); visitChildren(e); e.scope.availableColumns = table.resolvedColumns; visitChildren(e); } @override void visitDeleteStatement(DeleteStatement e) { final table = _resolveTableReference(e.from); e.scope.availableColumns = table.resolvedColumns; visitChildren(e); } void _handle(Queryable queryable, List availableColumns) { queryable.when( isTable: (table) { _resolveTableReference(table); 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 (var query in join.joins.map((j) => j.query)) { _handle(query, availableColumns); } }, ); } void _resolveSelect(SelectStatement s) { final availableColumns = []; for (var 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 (var resultColumn in s.columns) { if (resultColumn is StarResultColumn) { if (resultColumn.tableName != null) { final tableResolver = scope .resolve(resultColumn.tableName, orElse: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); }); usedColumns.addAll(tableResolver.resultSet.resolvedColumns); } else { // we have a * column, that would be all available columns usedColumns.addAll(availableColumns); } } else if (resultColumn is ExpressionResultColumn) { final name = _nameOfResultColumn(resultColumn); final column = ExpressionColumn(name: name, expression: resultColumn.expression); usedColumns.add(column); // make this column available if there is no other with the same name 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; } Table _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/prepare_ast.dart0000644000175000017500000001340213545361247020225 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Prepares the AST for further analysis. This visitor: /// - attaches the global scope containing table names and builtin functions /// - 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 ReferenceScope globalScope; final List _foundVariables = []; final AnalysisContext context; AstPreparingVisitor({@required this.globalScope, this.context}); void start(AstNode root) { root ..scope = globalScope ..accept(this); _resolveIndexOfVariables(); } @override void visitSelectStatement(SelectStatement e) { // 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 forked = scope.effectiveRoot.createChild(); e.scope = forked; } else { final forked = scope.createChild(); e.scope = forked; } for (var 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); } @override void visitResultColumn(ResultColumn e) { 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); } @override void visitQueryable(Queryable e) { 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); } @override void visitNumberedVariable(NumberedVariable e) { _foundVariables.add(e); visitChildren(e); } @override void visitNamedVariable(ColonNamedVariable e) { _foundVariables.add(e); visitChildren(e); } 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 (var 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, () { largestAssigned++; return largestAssigned; }); variable.resolvedIndex = index; } } } } lib/src/analysis/steps/reference_resolver.dart0000644000175000017500000000437313545361247021606 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) { if (e.resolved != null) { return super.visitReference(e); } 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, orElse: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${e.tableName}', relevantNode: e, )); }); final resultSet = tableResolver.resultSet; if (resultSet == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, relevantNode: e, )); } else { final column = resultSet.findColumn(e.columnName); if (column == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownColumn, relevantNode: 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) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownColumn, relevantNode: e)); } else { if (columns.length > 1) { context.reportError(AnalysisError( type: AnalysisErrorType.ambiguousReference, relevantNode: e, message: 'Could refer to any in ${columns.join(', ')}', )); } e.resolved = columns.first; } } visitChildren(e); } @override void visitAggregateExpression(AggregateExpression e) { if (e.windowName != null && e.resolved == null) { final resolved = e.scope.resolve(e.windowName); e.resolved = resolved; } visitChildren(e); } } lib/src/analysis/steps/set_parent_visitor.dart0000644000175000017500000000056513507167165021652 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 (var child in node.childNodes) { _applyFor(child, node); } } } lib/src/analysis/steps/type_resolver.dart0000644000175000017500000000304213545361247020621 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) { // called for every ast node, so we implement this here if (e is Expression) { types.resolveExpression(e); } else if (e is SelectStatement) { e.resolvedColumns.forEach(types.resolveColumn); } super.visitChildren(e); } @override void visitInsertStatement(InsertStatement e) { // 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 (var 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]); } } } } visitChildren(e); } } lib/src/analysis/types/data.dart0000644000175000017500000000373213507167165016645 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; 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() : this(type: BasicType.int, hint: const IsBoolean()); 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 ==(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(); } /// 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.dart0000644000175000017500000003620613545361247017576 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 = {}; 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; } ResolveResult resolveOrInfer(Typeable t) { if (t is Column) { return resolveColumn(t); } else if (t is Variable || t is DartExpressionPlaceholder) { 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 CompoundSelectColumn) { // todo maybe use a type that matches every column in here? return resolveColumn(column.columns.first); } 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) { return const ResolveResult.needsContext(); } else if (expr is Reference) { return resolveColumn(expr.resolved as Column); } else if (expr is Invocation) { return resolveFunctionCall(expr); } else if (expr is IsExpression || 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 { final type = _encapsulate(expr.childNodes.cast(), [BasicType.int, BasicType.real, BasicType.text, BasicType.blob]); return ResolveResult(type); } } else if (expr is CaseExpression) { return resolveExpression(expr.whens.first.then); } 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); } } throw StateError('Unknown expression $expr'); }, 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 NumericLiteral) { if (l is BooleanLiteral) { return const ResolveResult(ResolvedType.bool()); } else { 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); } /// Expands the parameters List _expandParameters(Invocation call) { final sqlParameters = call.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 call.scope.availableColumns.whereType().toList(); } throw ArgumentError('Unknown parameters: $sqlParameters'); } ResolveResult resolveFunctionCall(Invocation call) { return _cache((Invocation call) { final parameters = _expandParameters(call); final firstNullable = justResolve(parameters.first).nullable; final anyNullable = parameters.map(justResolve).any((r) => r.nullable); switch (call.name.toLowerCase()) { 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 ResolveResult(_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 ResolveResult(_encapsulate(parameters, [ BasicType.int, BasicType.real, BasicType.text, BasicType.blob ])).withNullable(true); case 'min': return ResolveResult(_encapsulate(parameters, [ BasicType.blob, BasicType.text, BasicType.int, BasicType.real ])).withNullable(true); } throw StateError('Unknown function: ${call.name}'); }, call); } ResolveResult _resolveFunctionArgument( Invocation parent, Expression argument) { return _cache((argument) { final functionName = parent.name.toLowerCase(); final args = _expandParameters(parent); // 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)); } return const ResolveResult.unknown(); }, argument); } ResolveResult inferType(Expression e) { return _cache((e) { final parent = e.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 Invocation) { // 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]. ResolvedType _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)); final notNull = argTypes.any((t) => !t.nullable); return 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 /// analyze. 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 ==(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/ast/ast.dart0000644000175000017500000002250513545361247014321 0ustar00pubpub00000000000000import 'package:collection/collection.dart'; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/utils/meta.dart'; part 'clauses/limit.dart'; part 'clauses/ordering.dart'; part 'common/queryables.dart'; part 'common/renamable.dart'; part 'common/tuple.dart'; part 'expressions/aggregate.dart'; part 'expressions/case.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/create_table.dart'; part 'statements/delete.dart'; part 'statements/insert.dart'; part 'statements/select.dart'; part 'statements/statement.dart'; part 'statements/update.dart'; /// A node in the abstract syntax tree of an SQL statement. abstract class AstNode with HasMetaMixin { /// 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; /// The first index in the source that belongs to this node. Not set for all /// nodes. int get firstPosition => first.span.start.offset; /// The (exclusive) last index of this node in the source. In other words, the /// first index that is _not_ a part of this node. Not set for all nodes. int get lastPosition => last.span.end.offset; FileSpan get span { if (!hasSpan) return null; return first.span.expand(last.span); } /// Whether a source span has been set on this node. The span describes what /// range in the source code is covered by this node. 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 (var 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. T accept(AstVisitor visitor); /// 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); } abstract class AstVisitor { T visitSelectStatement(SelectStatement e); T visitCompoundSelectStatement(CompoundSelectStatement e); T visitCompoundSelectPart(CompoundSelectPart e); T visitResultColumn(ResultColumn e); T visitInsertStatement(InsertStatement e); T visitDeleteStatement(DeleteStatement e); T visitUpdateStatement(UpdateStatement e); T visitCreateTableStatement(CreateTableStatement e); T visitOrderBy(OrderBy e); T visitOrderingTerm(OrderingTerm e); T visitLimit(Limit e); T visitQueryable(Queryable e); T visitJoin(Join e); T visitGroupBy(GroupBy e); T visitSetComponent(SetComponent e); T visitColumnDefinition(ColumnDefinition e); T visitColumnConstraint(ColumnConstraint e); T visitTableConstraint(TableConstraint e); T visitForeignKeyClause(ForeignKeyClause e); T visitBinaryExpression(BinaryExpression e); T visitStringComparison(StringComparisonExpression e); T visitUnaryExpression(UnaryExpression e); T visitIsExpression(IsExpression e); T visitBetweenExpression(BetweenExpression e); T visitLiteral(Literal e); T visitReference(Reference e); T visitFunction(FunctionExpression e); T visitSubQuery(SubQuery e); T visitExists(ExistsExpression e); T visitCaseExpression(CaseExpression e); T visitWhen(WhenComponent e); T visitTuple(Tuple e); T visitInExpression(InExpression e); T visitAggregateExpression(AggregateExpression e); T visitWindowDefinition(WindowDefinition e); T visitFrameSpec(FrameSpec e); T visitNumberedVariable(NumberedVariable e); T visitNamedVariable(ColonNamedVariable e); T visitMoorFile(MoorFile e); T visitMoorImportStatement(ImportStatement e); T visitMoorDeclaredStatement(DeclaredStatement e); T visitDartPlaceholder(DartPlaceholder e); } /// Visitor that walks down the entire tree, visiting all children in order. class RecursiveVisitor extends AstVisitor { @override T visitBinaryExpression(BinaryExpression e) => visitChildren(e); @override T visitStringComparison(StringComparisonExpression e) => visitChildren(e); @override T visitFunction(FunctionExpression e) => visitChildren(e); @override T visitGroupBy(GroupBy e) => visitChildren(e); @override T visitIsExpression(IsExpression e) => visitChildren(e); @override T visitBetweenExpression(BetweenExpression e) => visitChildren(e); @override T visitCaseExpression(CaseExpression e) => visitChildren(e); @override T visitWhen(WhenComponent e) => visitChildren(e); @override T visitTuple(Tuple e) => visitChildren(e); @override T visitInExpression(InExpression e) => visitChildren(e); @override T visitSubQuery(SubQuery e) => visitChildren(e); @override T visitExists(ExistsExpression e) => visitChildren(e); @override T visitSetComponent(SetComponent e) => visitChildren(e); @override T visitJoin(Join e) => visitChildren(e); @override T visitLimit(Limit e) => visitChildren(e); @override T visitLiteral(Literal e) => visitChildren(e); @override T visitNamedVariable(ColonNamedVariable e) => visitChildren(e); @override T visitNumberedVariable(NumberedVariable e) => visitChildren(e); @override T visitOrderBy(OrderBy e) => visitChildren(e); @override T visitOrderingTerm(OrderingTerm e) => visitChildren(e); @override T visitQueryable(Queryable e) => visitChildren(e); @override T visitReference(Reference e) => visitChildren(e); @override T visitResultColumn(ResultColumn e) => visitChildren(e); @override T visitSelectStatement(SelectStatement e) => visitChildren(e); @override T visitCompoundSelectStatement(CompoundSelectStatement e) => visitChildren(e); @override T visitCompoundSelectPart(CompoundSelectPart e) => visitChildren(e); @override T visitInsertStatement(InsertStatement e) => visitChildren(e); @override T visitDeleteStatement(DeleteStatement e) => visitChildren(e); @override T visitUpdateStatement(UpdateStatement e) => visitChildren(e); @override T visitCreateTableStatement(CreateTableStatement e) => visitChildren(e); @override T visitUnaryExpression(UnaryExpression e) => visitChildren(e); @override T visitColumnDefinition(ColumnDefinition e) => visitChildren(e); @override T visitTableConstraint(TableConstraint e) => visitChildren(e); @override T visitColumnConstraint(ColumnConstraint e) => visitChildren(e); @override T visitForeignKeyClause(ForeignKeyClause e) => visitChildren(e); @override T visitAggregateExpression(AggregateExpression e) => visitChildren(e); @override T visitWindowDefinition(WindowDefinition e) => visitChildren(e); @override T visitFrameSpec(FrameSpec e) => visitChildren(e); @override T visitMoorFile(MoorFile e) => visitChildren(e); @override T visitMoorImportStatement(ImportStatement e) => visitChildren(e); @override T visitMoorDeclaredStatement(DeclaredStatement e) => visitChildren(e); @override T visitDartPlaceholder(DartPlaceholder e) => visitChildren(e); @protected T visitChildren(AstNode e) { for (var child in e.childNodes) { child.accept(this); } return null; } } lib/src/ast/clauses/limit.dart0000644000175000017500000000136113545361247016304 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; Limit({this.count, this.offsetSeparator, this.offset}); @override T accept(AstVisitor visitor) { return visitor.visitLimit(this); } @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.dart0000644000175000017500000000257113545361247017003 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 T accept(AstVisitor visitor) => visitor.visitOrderBy(this); @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 T accept(AstVisitor visitor) => visitor.visitOrderingTerm(this); @override Iterable get childNodes => [expression]; @override bool contentEquals(OrderingTerm other) { return other.orderingMode == orderingMode; } } lib/src/ast/common/queryables.dart0000644000175000017500000001004313531033646017162 0ustar00pubpub00000000000000part of '../ast.dart'; /// Marker interface for something that can appear after a "FROM" in a select /// statement. abstract class Queryable extends AstNode { @override T accept(AstVisitor visitor) => visitor.visitQueryable(this); 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). class TableReference extends TableOrSubquery with ReferenceOwner implements Renamable, ResolvesToResultSet, VisibleToChildren { final String tableName; @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 T accept(AstVisitor visitor) => visitor.visitJoin(this); } /// 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.dart0000644000175000017500000000120213545361247016142 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 T accept(AstVisitor visitor) => visitor.visitTuple(this); @override Iterable get childNodes => expressions; @override bool contentEquals(Tuple other) => true; } lib/src/ast/expressions/aggregate.dart0000644000175000017500000001436313545361247020045 0ustar00pubpub00000000000000part of '../ast.dart'; class AggregateExpression extends Expression implements Invocation, 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 T accept(AstVisitor visitor) => visitor.visitAggregateExpression(this); @override Iterable get childNodes { return [ if (parameters is ExprFunctionParameters) ...(parameters as ExprFunctionParameters).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 T accept(AstVisitor visitor) => visitor.visitWindowDefinition(this); @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 T accept(AstVisitor visitor) => visitor.visitFrameSpec(this); @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 ==(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.dart0000644000175000017500000000153313507167165017026 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 T accept(AstVisitor visitor) => visitor.visitCaseExpression(this); @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 T accept(AstVisitor visitor) => visitor.visitWhen(this); @override Iterable get childNodes => [when, then]; @override bool contentEquals(WhenComponent other) => true; } lib/src/ast/expressions/expressions.dart0000644000175000017500000000013113506466600020461 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Expression extends AstNode implements Typeable {} lib/src/ast/expressions/function.dart0000644000175000017500000000355413530757447017751 0ustar00pubpub00000000000000part of '../ast.dart'; /// Interface for function calls, either a [FunctionExpression] or a /// [AggregateExpression]. abstract class Invocation extends Expression { /// The name of the function being called String get name; FunctionParameters get parameters; } class FunctionExpression extends Expression with ReferenceOwner implements Invocation { @override final String name; @override final FunctionParameters parameters; FunctionExpression({@required this.name, @required this.parameters}); @override T accept(AstVisitor visitor) => visitor.visitFunction(this); @override Iterable get childNodes { return [ if (parameters is ExprFunctionParameters) ...(parameters as ExprFunctionParameters).parameters ]; } @override bool contentEquals(FunctionExpression other) { if (other.name != name) { return false; } if (parameters is StarFunctionParameter) { return other.parameters is StarFunctionParameter; } else if (parameters is ExprFunctionParameters) { final typedParams = parameters as ExprFunctionParameters; final typedOther = other.parameters as ExprFunctionParameters; return typedParams.equals(typedOther); } return true; } } /// Marker interface for anything that can be inside the parentheses after a /// function name. abstract class FunctionParameters {} /// Using a star as a function parameter. For instance: "COUNT(*)". class StarFunctionParameter implements FunctionParameters { const StarFunctionParameter(); } class ExprFunctionParameters implements FunctionParameters { final bool distinct; final List parameters; ExprFunctionParameters({this.parameters = const [], this.distinct = false}); bool equals(ExprFunctionParameters other) { return other.distinct == distinct && other.parameters == parameters; } } lib/src/ast/expressions/literals.dart0000644000175000017500000000243313507167165017732 0ustar00pubpub00000000000000part of '../ast.dart'; // https://www.sqlite.org/syntax/literal-value.html abstract class Literal extends Expression { final Token token; Literal(this.token); @override T accept(AstVisitor visitor) => visitor.visitLiteral(this); @override final Iterable childNodes = const []; } class NullLiteral extends Literal { NullLiteral(Token token) : super(token); @override bool contentEquals(NullLiteral other) => true; } class NumericLiteral extends Literal { final num number; bool get isInt => number.toInt() == number; NumericLiteral(this.number, Token token) : super(token); @override bool contentEquals(NumericLiteral other) => other.number == number; } class BooleanLiteral extends NumericLiteral { BooleanLiteral.withFalse(Token token) : super(0, token); BooleanLiteral.withTrue(Token token) : super(1, token); } class StringLiteral extends Literal { final String data; final bool isBinary; StringLiteral(StringLiteralToken token) : data = token.value, isBinary = token.binary, super(token); StringLiteral.from(Token token, this.data, {this.isBinary = false}) : super(token); @override bool contentEquals(StringLiteral other) { return other.isBinary == isBinary && other.data == data; } } lib/src/ast/expressions/reference.dart0000644000175000017500000000201513545361247020044 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 T accept(AstVisitor visitor) => visitor.visitReference(this); @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.dart0000644000175000017500000001022213545361247017376 0ustar00pubpub00000000000000part of '../ast.dart'; class UnaryExpression extends Expression { final Token operator; final Expression inner; UnaryExpression(this.operator, this.inner); @override T accept(AstVisitor visitor) => visitor.visitUnaryExpression(this); @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 T accept(AstVisitor visitor) => visitor.visitBinaryExpression(this); @override Iterable get childNodes => [left, right]; @override bool contentEquals(BinaryExpression other) { return other.operator.type == operator.type; } } 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 T accept(AstVisitor visitor) => visitor.visitStringComparison(this); @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 T accept(AstVisitor visitor) { return visitor.visitIsExpression(this); } @override Iterable get childNodes => [left, right]; @override bool contentEquals(IsExpression 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 T accept(AstVisitor visitor) => visitor.visitBetweenExpression(this); @override Iterable 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 T accept(AstVisitor visitor) => visitor.visitInExpression(this); @override Iterable 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 T accept(AstVisitor visitor) { return expression.accept(visitor); } @override Iterable get childNodes => [expression]; @override bool contentEquals(Parentheses other) => true; } lib/src/ast/expressions/subquery.dart0000644000175000017500000000140613507167165017771 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 SelectStatement select; SubQuery({this.select}); @override T accept(AstVisitor visitor) => visitor.visitSubQuery(this); @override Iterable get childNodes => [select]; @override bool contentEquals(SubQuery other) => true; } class ExistsExpression extends Expression { final SelectStatement select; ExistsExpression({@required this.select}); @override T accept(AstVisitor visitor) => visitor.visitExists(this); @override Iterable get childNodes => [select]; @override bool contentEquals(ExistsExpression other) => true; } lib/src/ast/expressions/variables.dart0000644000175000017500000000174613545361247020070 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); @override T accept(AstVisitor visitor) { return visitor.visitNumberedVariable(this); } @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 T accept(AstVisitor visitor) { return visitor.visitNamedVariable(this); } @override Iterable get childNodes => []; @override bool contentEquals(ColonNamedVariable other) { return other.name == name; } } lib/src/ast/moor/declared_statement.dart0000644000175000017500000000116613545361247020335 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 String name; final CrudStatement statement; IdentifierToken identifier; Token colon; DeclaredStatement(this.name, this.statement); @override T accept(AstVisitor visitor) => visitor.visitMoorDeclaredStatement(this); @override Iterable get childNodes => [statement]; @override bool contentEquals(DeclaredStatement other) { return other.name == name; } } lib/src/ast/moor/import_statement.dart0000644000175000017500000000105613545361247020102 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 T accept(AstVisitor visitor) => visitor.visitMoorImportStatement(this); @override final Iterable childNodes = const []; @override bool contentEquals(ImportStatement other) { return other.importedFile == importedFile; } } lib/src/ast/moor/inline_dart.dart0000644000175000017500000000475713545361247017007 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 T accept(AstVisitor visitor) => visitor.visitDartPlaceholder(this); 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.dart0000644000175000017500000000134613545361247016461 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 T accept(AstVisitor visitor) => visitor.visitMoorFile(this); @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.dart0000644000175000017500000001255613545361247020504 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; ColumnDefinition( {@required this.columnName, @required this.typeName, this.constraints = const []}); @override T accept(AstVisitor visitor) => visitor.visitColumnDefinition(this); @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 T accept(AstVisitor visitor) => visitor.visitColumnConstraint(this); 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 []; } lib/src/ast/schema/table_definition.dart0000644000175000017500000000442713527467305020276 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 T accept(AstVisitor visitor) => visitor.visitForeignKeyClause(this); @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; TableConstraint(this.name); @override T accept(AstVisitor visitor) => visitor.visitTableConstraint(this); @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/create_table.dart0000644000175000017500000000254013545361247020330 0ustar00pubpub00000000000000part of '../ast.dart'; /// A "CREATE TABLE" statement, see https://www.sqlite.org/lang_createtable.html /// for the individual components. class CreateTableStatement extends Statement with SchemaStatement implements PartOfMoorFile { final bool ifNotExists; final String tableName; final List columns; final List tableConstraints; final bool withoutRowId; /// 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 openingBracket; Token closingBracket; CreateTableStatement( {this.ifNotExists = false, @required this.tableName, this.columns = const [], this.tableConstraints = const [], this.withoutRowId = false, this.overriddenDataClassName}); @override T accept(AstVisitor visitor) => visitor.visitCreateTableStatement(this); @override Iterable get childNodes => [...columns, ...tableConstraints]; @override bool contentEquals(CreateTableStatement other) { return other.ifNotExists == ifNotExists && other.tableName == tableName && other.withoutRowId == withoutRowId && other.overriddenDataClassName == overriddenDataClassName; } } lib/src/ast/statements/delete.dart0000644000175000017500000000074313545361247017163 0ustar00pubpub00000000000000part of '../ast.dart'; class DeleteStatement extends Statement with CrudStatement implements HasWhereClause { final TableReference from; @override final Expression where; DeleteStatement({@required this.from, this.where}); @override T accept(AstVisitor visitor) => visitor.visitDeleteStatement(this); @override Iterable get childNodes => [from, if (where != null) where]; @override bool contentEquals(DeleteStatement other) => true; } lib/src/ast/statements/insert.dart0000644000175000017500000000456613545361247017234 0ustar00pubpub00000000000000part of '../ast.dart'; enum InsertMode { insert, replace, insertOrReplace, insertOrRollback, insertOrAbort, insertOrFail, insertOrIgnore } class InsertStatement extends Statement with 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( {this.mode = InsertMode.insert, @required this.table, @required this.targetColumns, @required this.source}); @override T accept(AstVisitor visitor) => visitor.visitInsertStatement(this); @override Iterable get childNodes sync* { 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 SelectStatement stmt; SelectInsertSource(this.stmt); @override Iterable get childNodes => [stmt]; } /// Use `DEFAULT VALUES` for an insert statement. class DefaultValues extends InsertSource { const DefaultValues(); @override final Iterable childNodes = const []; } lib/src/ast/statements/select.dart0000644000175000017500000001017713545361247017202 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class BaseSelectStatement extends Statement with CrudStatement, 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; } 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( {this.distinct = false, this.columns, this.from, this.where, this.groupBy, this.windowDeclarations = const [], this.orderBy, this.limit}); @override T accept(AstVisitor visitor) { return visitor.visitSelectStatement(this); } @override Iterable get childNodes { return [ ...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({ @required this.base, this.additional = const [], }); @override Iterable get childNodes { return [base, ...additional]; } @override T accept(AstVisitor visitor) { return visitor.visitCompoundSelectStatement(this); } @override bool contentEquals(CompoundSelectStatement other) { // this class doesn't contain anything but child nodes return true; } } abstract class ResultColumn extends AstNode { @override T accept(AstVisitor visitor) => visitor.visitResultColumn(this); } /// 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 T accept(AstVisitor visitor) => visitor.visitGroupBy(this); @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 T accept(AstVisitor visitor) => visitor.visitCompoundSelectPart(this); @override bool contentEquals(CompoundSelectPart other) => mode == other.mode; } lib/src/ast/statements/statement.dart0000644000175000017500000000073213545361247017723 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Statement extends AstNode { Token semicolon; } /// Marker mixin for statements that read from an existing table structure. mixin CrudStatement on Statement {} /// Interface for statements that have a primary where clause (select, update, /// delete). abstract class HasWhereClause extends Statement { Expression get where; } /// Marker mixin for statements that change the table structure. mixin SchemaStatement on Statement {} lib/src/ast/statements/update.dart0000644000175000017500000000262113545361247017200 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 Statement with CrudStatement implements HasWhereClause { final FailureMode or; final TableReference table; final List set; @override final Expression where; UpdateStatement( {this.or, @required this.table, @required this.set, this.where}); @override T accept(AstVisitor visitor) => visitor.visitUpdateStatement(this); @override Iterable get childNodes => [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 T accept(AstVisitor visitor) => visitor.visitSetComponent(this); @override Iterable get childNodes => [column, expression]; @override bool contentEquals(SetComponent other) => true; } 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/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.dart0000644000175000017500000000636213545361247020161 0ustar00pubpub00000000000000import 'package:collection/collection.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; part 'descriptions/description.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; 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) { _hintsView = UnmodifiableListView(_hints); } /// Suggest completions at a specific position. /// /// This api will change in the future. ComputedSuggestions suggestCompletions(int offset) { if (_hints.isEmpty) { return ComputedSuggestions(-1, -1, []); } final hint = foundHints[_lastHintBefore(offset)]; final suggestions = hint.description.suggest(CalculationRequest()).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 {} lib/src/engine/autocomplete/suggestion.dart0000644000175000017500000000163113545361247021075 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); } lib/src/engine/sql_engine.dart0000644000175000017500000001630213545361247016332 0ustar00pubpub00000000000000import 'dart:collection'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.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'; class SqlEngine { /// All tables registered with [registerTable]. final List
knownTables = []; /// 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; SqlEngine({this.useMoorExtensions = false}); /// Registers the [table], which means that it can later be used in sql /// statements. void registerTable(Table table) { knownTables.add(table); } ReferenceScope _constructRootScope() { final scope = ReferenceScope(null); for (var table in knownTables) { scope.register(table.name, table); } 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: useMoorExtensions); final tokens = scanner.scanTokens(); if (scanner.errors.isNotEmpty) { throw CumulatedTokenizerException(scanner.errors); } return tokens; } /// Parses the [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: 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(useMoorExtensions); final tokens = tokenize(content); final autoComplete = AutoCompleteEngine(tokens); final tokensForParser = tokens.where((t) => !t.invisibleToParser).toList(); final parser = Parser(tokensForParser, useMoor: true, autoComplete: autoComplete); final moorFile = parser.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. AnalysisContext analyze(String sql) { final result = parse(sql); return analyzeParsed(result); } /// 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. AnalysisContext analyzeParsed(ParseResult result) { final node = result.rootNode; final context = AnalysisContext(node, result.sql); _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. AnalysisContext analyzeNode(AstNode node, String file) { final context = AnalysisContext(node, file); _analyzeContext(context); return context; } void _analyzeContext(AnalysisContext context) { final node = context.root; final scope = _constructRootScope(); try { AstPreparingVisitor(globalScope: scope, context: context).start(node); if (node is CrudStatement) { node ..accept(ColumnResolver(context)) ..accept(ReferenceResolver(context)) ..accept(TypeResolvingVisitor(context)); } } catch (e) { // todo should we do now? AFAIK, everything that causes an exception // is added as an error contained in the context. } } } /// The result of parsing an sql query. Contains the root of the AST and all /// errors that might have occurred during parsing. class ParseResult { /// The topmost node in the sql AST that was parsed. final AstNode rootNode; /// The tokens that were scanned in the source file, including those that are /// [Token.invisibleToParser]. final List tokens; /// A list of all errors that occurred during parsing. [ParsingError.toString] /// returns a helpful description of what went wrong, along with the position /// where the error occurred. final List errors; /// The sql source that created the AST at [rootNode]. final String sql; /// The engine which can be used to handle auto-complete requests on this /// result. final AutoCompleteEngine autoCompleteEngine; ParseResult._(this.rootNode, this.tokens, this.errors, this.sql, this.autoCompleteEngine) { const SetParentVisitor().startAtRoot(rootNode); } /// Attempts to find the most relevant (bottom-most in the AST) nodes that /// intersects with the source range from [offset] to [offset] + [length]. List findNodesAtPosition(int offset, {int length = 0}) { if (tokens.isEmpty || 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.dart0000644000175000017500000005057413545361247016445 0ustar00pubpub00000000000000part of 'parser.dart'; mixin CrudParser on ParserBase { @override BaseSelectStatement select({bool noCompound}) { if (noCompound == true) { return _selectNoCompound(); } else { final first = _selectNoCompound(); final parts = []; while (true) { 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 { return CompoundSelectStatement( base: first, additional: parts, )..setSpan(first.first, _previous); } } } SelectStatement _selectNoCompound() { 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(); return SelectStatement( distinct: distinct, columns: resultColumns, from: from, where: where, groupBy: groupBy, windowDeclarations: windowDecls, orderBy: orderBy, limit: limit, )..setSpan(selectToken, _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 innerStmt = _selectNoCompound(); _consume(TokenType.rightParen, 'Expected a right bracket to terminate the inner select'); final alias = _as(); return SelectStatementAsSource( statement: innerStmt, as: alias?.identifier); } _error('Expected a table name or a nested select statement'); } TableReference _tableReference() { if (_matchOne(TokenType.identifier)) { // ignore the schema name, it's not supported. Besides that, we're on the // first branch in the diagram here final firstToken = _previous as IdentifierToken; final tableName = firstToken.identifier; final alias = _as(); return TableReference(tableName, alias?.identifier) ..setSpan(firstToken, _previous); } return null; } JoinClause _joinClause(TableOrSubquery start) { var operator = _parseJoinOperatorNoComma(); if (operator == null) { return null; } final joins = []; while (operator != null) { 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, )); // 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); } /// 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)) { _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); } 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() { 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(from: table, where: where) ..setSpan(deleteToken, _previous); } UpdateStatement _update() { 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( or: failureMode, table: table, set: set, where: where) ..setSpan(updateToken, _previous); } InsertStatement _insertStmt() { 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( mode: insertMode, table: table, targetColumns: targetColumns, source: source, )..setSpan(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(_selectNoCompound()); } } @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(), )..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.dart0000644000175000017500000003023213545361247020057 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; final ops = const [ TokenType.equal, TokenType.doubleEqual, TokenType.exclamationEqual, TokenType.lessMore, TokenType.$is, ]; final stringOps = const [ TokenType.like, TokenType.glob, TokenType.match, TokenType.regexp, ]; while (true) { 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 = select(noCompound: true) as SelectStatement; _consume(TokenType.rightParen, 'Expected closing paranthesis to finish EXISTS expression'); return ExistsExpression(select: selectStmt) ..setSpan(existsToken, _previous); } return _postfix(); } Expression _postfix() { // todo parse ISNULL, NOTNULL, NOT NULL, etc. // I don't even know the precedence ¯\_(ツ)_/¯ (probably not higher than // unary) var expression = _primary(); while (_matchOne(TokenType.collate)) { final collateOp = _previous; final collateFun = _consume(TokenType.identifier, 'Expected a collating sequence') as IdentifierToken; expression = CollateExpression( inner: expression, operator: collateOp, collateFunction: collateFun, )..setSpan(expression.first, collateFun); } 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; if (_peek.type == TokenType.select) { final stmt = select(noCompound: true) as SelectStatement; _consume(TokenType.rightParen, 'Expected a closing bracket'); return SubQuery(select: stmt)..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(...) 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)) { 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'); } 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 const StarFunctionParameter(); } if (_check(TokenType.rightParen)) { // nothing between the brackets -> empty parameter list return ExprFunctionParameters(parameters: const []); } final distinct = _matchOne(TokenType.distinct); final parameters = []; do { parameters.add(expression()); } while (_matchOne(TokenType.comma)); return ExprFunctionParameters(distinct: distinct, parameters: parameters); } 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 = []; final subQuery = select(noCompound: true) as SelectStatement; 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.dart0000644000175000017500000002162313545361247016775 0ustar00pubpub00000000000000import 'package:meta/meta.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 = const [ TokenType.shiftLeft, TokenType.shiftRight, TokenType.ampersand, TokenType.pipe, ]; final _startOperators = const [ 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 (var 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 (_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 void _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(); } return _consume(TokenType.identifier, message) as IdentifierToken; } // Common operations that we are referenced very often Expression expression(); /// 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]. /// /// See also: /// https://www.sqlite.org/lang_select.html BaseSelectStatement select({bool noCompound}); Literal _literalOrNull(); OrderingMode _orderingModeOrNull(); /// https://www.sqlite.org/syntax/window-defn.html WindowDefinition _windowDefinition(); } 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 ??= _createTable(); 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); } CrudStatement _crud() { // writing select() ?? _deleteStmt() and so on doesn't cast to CrudStatement // for some reason. CrudStatement stmt = select(); stmt ??= _deleteStmt(); stmt ??= _update(); stmt ??= _insertStmt(); return stmt; } 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(_createTable); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_createTable)) { 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() { if (_check(TokenType.identifier) || _peek is KeywordToken) { final name = _consumeIdentifier('Expected a name for a declared query'); final colon = _consume(TokenType.colon, 'Expected colon (:) followed by a query'); final stmt = _crud(); return DeclaredStatement(name.identifier, stmt) ..identifier = name ..colon = colon; } return null; } /// 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 catch (_) { _lastStmtHadParsingError = true; // the error is added to the list errors, so ignore. We skip to the next // semicolon to parse the next statement. _synchronize(); } if (result == null) return null; if (_matchOne(TokenType.semicolon)) { result.semicolon = _previous; } result.setSpan(first, _previous); return result; } void _synchronize() { // fast-forward to the token after th next semicolon while (!_isAtEnd && _advance().type != TokenType.semicolon) {} } } lib/src/reader/parser/schema.dart0000644000175000017500000002716113545361247016744 0ustar00pubpub00000000000000part of 'parser.dart'; mixin SchemaParser on ParserBase { CreateTableStatement _createTable() { _suggestHint( const HintDescription.tokens([TokenType.create, TokenType.table])); if (!_matchOne(TokenType.create)) return null; final first = _previous; _suggestHint(HintDescription.token(TokenType.table)); _consume(TokenType.table, 'Expected TABLE keyword here'); var ifNotExists = false; 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'); ifNotExists = true; } final tableIdentifier = _consumeIdentifier('Expected a table name'); // 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 { final tableConstraint = _tableConstraintOrNull(); if (tableConstraint != null) { encounteredTableConstraint = true; tableConstraints.add(tableConstraint); } else { if (encounteredTableConstraint) { _error('Expected another table constraint'); } else { columns.add(_columnDefinition()); } } } 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; } String overriddenName; if (enableMoorExtensions && _matchOne(TokenType.as)) { overriddenName = _consumeIdentifier('Expected the name for the data class').identifier; } return CreateTableStatement( ifNotExists: ifNotExists, tableName: tableIdentifier.identifier, withoutRowId: withoutRowId, columns: columns, tableConstraints: tableConstraints, overriddenDataClassName: overriddenName, ) ..setSpan(first, _previous) ..openingBracket = leftParen ..closingBracket = rightParen; } ColumnDefinition _columnDefinition() { final name = _consume(TokenType.identifier, 'Expected a column name') as IdentifierToken; final typeTokens = _typeName(); String typeName; if (typeTokens != null) { final typeSpan = typeTokens.first.span.expand(typeTokens.last.span); typeName = typeSpan.text; } 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; } 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 paranthesis to finish type name'); typeNames.add(_previous); } return typeNames; } ColumnConstraint _columnConstraint({bool orNull = false}) { final first = _peek; final resolvedName = _constraintNameOrNull(); 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); } // 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 name = _constraintNameOrNull(); 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(); return KeyClause(name, isPrimaryKey: isPrimaryKey, indexedColumns: columns, onConflict: conflictClause) ..setSpan(first, _previous); } else if (_matchOne(TokenType.check)) { final expr = _expressionInParentheses(); return CheckTable(name, expr)..setSpan(first, _previous); } else if (_matchOne(TokenType.foreign)) { _consume(TokenType.key, 'Expected KEY to start FOREIGN KEY clause'); final columns = _listColumnsInParentheses(allowEmpty: false); final clause = _foreignKeyClause(); return ForeignKeyTableConstraint(name, columns: columns, clause: clause) ..setSpan(first, _previous); } 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; } String _constraintNameOrNull() { if (_matchOne(TokenType.constraint)) { final name = _consumeIdentifier('Expect a name for the constraint here'); return name.identifier; } 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/tokenizer/scanner.dart0000644000175000017500000002647713545361247017664 0ustar00pubpub00000000000000import 'package:source_span/source_span.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/reader/tokenizer/utils.dart'; class Scanner { final String source; /// 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); 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 '(': _addToken(TokenType.leftParen); break; case ')': _addToken(TokenType.rightParen); break; case ',': _addToken(TokenType.comma); break; case '.': if (!_isAtEnd && isDigit(_peek())) { _numeric(char); } else { _addToken(TokenType.dot); } break; case '+': _addToken(TokenType.plus); break; case '-': if (_match('-')) { _lineComment(); } else { _addToken(TokenType.minus); } break; case '*': _addToken(TokenType.star); break; case '/': if (_match('*')) { _cStyleComment(); } else { _addToken(TokenType.slash); } break; case '%': _addToken(TokenType.percent); break; case '&': _addToken(TokenType.ampersand); break; case '|': _addToken(_match('|') ? TokenType.doublePipe : TokenType.pipe); break; case '<': if (_match('=')) { _addToken(TokenType.lessEqual); } else if (_match('<')) { _addToken(TokenType.shiftLeft); } else if (_match('>')) { _addToken(TokenType.lessMore); } else { _addToken(TokenType.less); } break; case '>': if (_match('=')) { _addToken(TokenType.moreEqual); } else if (_match('>')) { _addToken(TokenType.shiftRight); } else { _addToken(TokenType.more); } break; case '!': if (_match('=')) { _addToken(TokenType.exclamationEqual); } break; case '=': _addToken(_match('=') ? TokenType.doubleEqual : TokenType.equal); break; case '~': _addToken(TokenType.tilde); break; case '?': // if the next chars are numbers, this is an explicitly index variable final buffer = StringBuffer(); while (!_isAtEnd && isDigit(_peek())) { buffer.write(_nextChar()); } int explicitIndex; if (buffer.isNotEmpty) { explicitIndex = int.parse(buffer.toString()); } tokens.add(QuestionMarkVariableToken(_currentSpan, explicitIndex)); break; case ':': final name = _matchColumnName(); if (name == null) { _addToken(TokenType.colon); } else { tokens.add(ColonVariableToken(_currentSpan, ':$name')); } break; case r'$': final name = _matchColumnName(); tokens.add(DollarSignVariableToken(_currentSpan, name)); break; case ';': _addToken(TokenType.semicolon); break; case 'x': if (_match("'")) { _string(binary: false); } else { _identifier(); } break; case "'": _string(); break; case '"': // todo sqlite also allows string literals with double ticks, we don't _identifier(escapedInQuotes: true); break; case '`': if (scanMoorTokens) { _inlineDart(); } else { _unexpectedToken(); } break; case ' ': case '\t': case '\n': // 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)); } String _nextChar() { _currentOffset++; return source.substring(_currentOffset - 1, _currentOffset); } String _peek() { if (_isAtEnd) throw StateError('Reached end of source'); return source.substring(_currentOffset, _currentOffset + 1); } bool _match(String expected) { if (_isAtEnd) return false; if (source.substring(_currentOffset, _currentOffset + 1) != expected) { return false; } _currentOffset++; return true; } void _addToken(TokenType type) { tokens.add(Token(type, _currentSpan)); } void _string({bool binary = false}) { while (_peek() != "'" && !_isAtEnd) { _nextChar(); } // Issue an error if the string is unterminated if (_isAtEnd) { errors.add(TokenizerError('Unterminated string', _currentLocation)); } // consume the closing "'" _nextChar(); final value = source.substring(_startOffset + 1, _currentOffset - 1); tokens.add(StringLiteralToken(value, _currentSpan, binary: binary)); } void _numeric(String 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 == '0') { if (!_isAtEnd && (_peek() == 'x' || _peek() == 'X')) { _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 == '.') { // 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() == '.') { _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() == 'e' || _peek() == 'E')) { _nextChar(); // consume e or E if (_isAtEnd) { errors.add(TokenizerError( 'Unexpected end of file. Expected digits for the scientific notation', _currentLocation)); return; } final char = _nextChar(); if (isDigit(char)) { consumeDigits(); _addToken(TokenType.numberLiteral); return; } else { if (char == '+' || char == '-') { _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 (_peek() != '"' && !_isAtEnd) { _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()..write(_nextChar()); while (!_isAtEnd && continuesColumnName(_peek())) { buffer.write(_nextChar()); } return buffer.toString(); } void _inlineDart() { // inline starts with a `, we just need to find the matching ` that // terminates this token. while (_peek() != '`' && !_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() != '\n') { contentBuilder.write(_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('*')) { if (!_isAtEnd && _match('/')) { break; } else { // write the * we otherwise forgot to write contentBuilder.write('*'); } } else { contentBuilder.write(_nextChar()); } } tokens.add(CommentToken( CommentMode.cStyle, contentBuilder.toString(), _currentSpan)); } } lib/src/reader/tokenizer/token.dart0000644000175000017500000002115013545361247017332 0ustar00pubpub00000000000000import 'package:source_span/source_span.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, // todo at is not used at the moment at, dollarSignVariable, stringLiteral, numberLiteral, $true, $false, $null, 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, table, $if, without, rowid, constraint, autoincrement, primary, foreign, key, unique, check, $default, $values, conflict, references, cascade, restrict, no, action, semicolon, comment, eof, /// Moor specific token, used to declare a type converters mapped, inlineDart, import, } 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, '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, 'IF': TokenType.$if, '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, '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, }; /// Maps [TokenType]s which are keywords to their lexeme. final 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, }; /// Returns true if the [type] belongs to a keyword bool isKeyword(TokenType type) => reverseKeywords.containsKey(type); class Token { final TokenType type; /// Whether this token should be invisible to the parser. We use this for /// comment tokens. bool get invisibleToParser => false; 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 String toString() { return '$type: $lexeme'; } } 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. 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); } /// 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; 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; } 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.dart0000644000175000017500000000204113506466600017344 0ustar00pubpub00000000000000const _charCodeZero = 48; // '0'.codeUnitAt(0); const _charCodeNine = 57; // '9'.codeUnitAt(0); const _charCodeLowerA = 97; // 'a'.codeUnitAt(0); const _charCodeLowerF = 102; // 'f'.codeUnitAt(0); const _charCodeA = 65; // 'A'.codeUnitAt(0); const _charCodeF = 79; // 'F'.codeUnitAt(0); const _charCodeZ = 90; // 'Z'.codeUnitAt(0); const _charCodeLowerZ = 122; // 'z'.codeUnitAt(0); bool isDigit(String char) { final code = char.codeUnitAt(0); return _charCodeZero <= code && code <= _charCodeNine; } bool isHexDigit(String char) { final code = char.codeUnitAt(0); return (_charCodeLowerA <= code && code <= _charCodeLowerF) || (_charCodeA <= code && code <= _charCodeF) || (_charCodeZero <= code && code <= _charCodeNine); } bool canStartColumnName(String char) { final code = char.codeUnitAt(0); return char == '_' || (_charCodeLowerA <= code && code <= _charCodeLowerZ) || (_charCodeA <= code && code <= _charCodeZ); } bool continuesColumnName(String char) { return canStartColumnName(char) || isDigit(char); } 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.yaml0000644000175000017500000000111413545361247013050 0ustar00pubpub00000000000000name: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.3.0 homepage: https://github.com/simolus3/moor/tree/develop/sqlparser #homepage: https://moor.simonbinder.eu/ issue_tracker: https://github.com/simolus3/moor/issues author: Simon Binder environment: sdk: '>=2.2.2 <3.0.0' dependencies: meta: ^1.1.0 collection: ^1.14.11 source_span: ^1.5.5 dev_dependencies: test: ^1.6.0 test_core: any # version will be determined by "test" path: ^1.6.0 coverage: git: https://github.com/simolus3/coverage.gittest/analysis/data.dart0000644000175000017500000000105013527467305015113 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.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 anotherId = TableColumn('id', const ResolvedType(type: BasicType.int)); final dateTime = TableColumn( 'date', const ResolvedType(type: BasicType.int, hint: IsDateTime())); final 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/reference_resolver_test.dart0000644000175000017500000000631713545361247021131 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'); 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); }); 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'), ), ); }); 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 current_row() 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/from_create_table.dart0000644000175000017500000000352413527467305021107 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/analysis/type_resolver_test.dart0000644000175000017500000000657313545361247020160 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)), }; 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(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/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.dart0000644000175000017500000000251413545361247020657 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; void main() { test('suggests a CREATE TABLE statements for an empty file', () { final engine = SqlEngine(useMoorExtensions: true); final parseResult = engine.parseMoorFile(''); final suggestions = parseResult.autoCompleteEngine.suggestCompletions(0); expect(suggestions.anchor, 0); expect(suggestions.suggestions, contains(hasCode('CREATE TABLE'))); }); test('suggests completions for started expressions', () { final engine = SqlEngine(useMoorExtensions: true); final parseResult = engine.parseMoorFile('creat'); final suggestions = parseResult.autoCompleteEngine.suggestCompletions(0); expect(suggestions.anchor, 0); expect(suggestions.suggestions, contains(hasCode('CREATE TABLE'))); }); } dynamic hasCode(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(item, Map matchState) { return item is Suggestion && codeMatcher.matches(item.code, matchState); } } 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/parser/create_table_test.dart0000644000175000017500000001002013545361247017317 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/utils/ast_equality.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 expressions when in moor mode', () { const stmt = 'CREATE TABLE a (b NOT NULL MAPPED BY `Mapper()` PRIMARY KEY)'; final parsed = SqlEngine(useMoorExtensions: true).parse(stmt).rootNode; enforceEqual( parsed, CreateTableStatement(tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: null, constraints: [ NotNull(null), MappedBy(null, inlineDart('Mapper()')), PrimaryKeyColumn(null), ], ), ]), ); }); } 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.dart0000644000175000017500000001121713545361247017115 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: const 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)), ), ]), ), ], ), ), }; 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.dart0000644000175000017500000000357213545361247016676 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.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; '''; void main() { test('parses moor files', () { final parsed = SqlEngine(useMoorExtensions: true).parseMoorFile(content); final file = parsed.rootNode; enforceHasSpan(file); enforceEqual( file, 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( 'all', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], where: DartExpressionPlaceholder(name: 'predicate'), ), ), ]), ); }); } test/parser/multiple_statements.dart0000644000175000017500000000465413545361247017770 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'; void main() { test('can parse multiple statements', () { final sql = 'a: UPDATE tbl SET a = b; b: SELECT * FROM tbl;'; final tokens = Scanner(sql).scanTokens(); final moorFile = Parser(tokens).moorFile(); final statements = moorFile.statements; enforceEqual( statements[0], DeclaredStatement( 'a', UpdateStatement( table: TableReference('tbl', null), set: [ SetComponent( column: Reference(columnName: 'a'), expression: Reference(columnName: 'b'), ), ], ), ), ); enforceEqual( statements[1], DeclaredStatement( 'b', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ); }); test('recovers from invalid statements', () { final 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( 'b', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ); }); test('parses imports and declared statements in moor mode', () { final 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( 'query', SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('tbl', null)], ), ), ); }); } test/parser/partition_test.dart0000644000175000017500000000426513531501512016716 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: const 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(); enforceEqual(expression, expected); }); }); }); } 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.dart0000644000175000017500000000465513542630206017137 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) { 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.dart0000644000175000017500000000141213507167165020020 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; 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.dart0000644000175000017500000000326513512315623017306 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; 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; 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; 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.dart0000644000175000017500000000146113527467305020004 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; 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.dart0000644000175000017500000000124613527467305016203 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'utils.dart'; final 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.dart0000644000175000017500000000254213545361247015020 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)); } void testStatement(String sql, AstNode expected, {bool moorMode = false}) { final parsed = SqlEngine(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, 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.dart0000644000175000017500000000143113545361247017407 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', () { final 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.dart0000644000175000017500000000265413531501512017706 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, '1.123': TokenType.numberLiteral, '1.32e5': TokenType.numberLiteral, '.123e-3': TokenType.numberLiteral, '0xFF13': TokenType.numberLiteral, '0Xf13A': TokenType.numberLiteral, 'SELECT': TokenType.select, '"UPDATE"': TokenType.identifier, }; void main() { test('parses single tokens', () { testCases.forEach(expectFullToken); }); } tool/coverage.dart0000644000175000017500000000055613527467305014162 0ustar00pubpub00000000000000import 'dart:convert'; import 'dart:io'; import 'package:coverage/coverage.dart'; import 'package:path/path.dart'; void main() async { final tests = join(File.fromUri(Platform.script).parent.path, 'tester.dart'); final coverage = await runAndCollect(tests, onExit: true, printOutput: true); File('coverage.json').writeAsStringSync(json.encode(coverage)); } tool/tester.dart0000644000175000017500000000023113527467305013663 0ustar00pubpub00000000000000import 'package:test_core/src/executable.dart' as test; void main() async { await test.main([]); print('Tests ran, now collecting coverage...'); }