.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.md0000644000175000017500000000145713527467305012350 0ustar00pubpub00000000000000## 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.md0000644000175000017500000000653613527467305012021 0ustar00pubpub00000000000000# sqlparser An sql parser and static analyzer, written in pure Dart. At the moment, this library only targets the sqlite dialect and some advanced features aren't supported yet. ## Features This library can parse most statements and perform type analysis for parameters and returned columns. It supports joins, `group by`, nested sql statements, updates and deletes, and more. ### Just parsing 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. - For now, `INSERT` statements are not supported, but they will be soon. - Compound select statements (`UNION` / `INTERSECT`) are not supported yet - Common table expressions are not supported - Some advanced expressions, like `CAST`s aren't supported yet. 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.dart0000644000175000017500000000044713527467305014173 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' show CumulatedTokenizerException; lib/src/analysis/analysis.dart0000644000175000017500000000110713527467305016406 0ustar00pubpub00000000000000import 'dart:math'; import 'package:meta/meta.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/token.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/reference_finder.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.dart0000644000175000017500000000216313507167165016251 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); } lib/src/analysis/error.dart0000644000175000017500000000125413507167165015716 0ustar00pubpub00000000000000part of 'analysis.dart'; class AnalysisError { final AstNode relevantNode; final String message; final AnalysisErrorType type; AnalysisError({@required this.type, this.message, this.relevantNode}); @override String toString() { final first = relevantNode?.first?.span; final last = relevantNode?.last?.span; if (first != null && last != null) { final span = first.expand(last); return span.message(message ?? type.toString(), color: true); } else { return 'Error: $type: $message at $relevantNode'; } } } enum AnalysisErrorType { referencedUnknownTable, referencedUnknownColumn, ambiguousReference, unknownFunction, } lib/src/analysis/schema/column.dart0000644000175000017500000000213313527467305017320 0ustar00pubpub00000000000000part of '../analysis.dart'; /// A column that appears in a [ResultSet]. Has a type and a name. abstract class Column with Referencable implements Typeable { /// The name of this column in the result set. String get name; const Column(); } /// A column that is part of a table. class TableColumn extends Column { @override final String name; /// The type of this column, which is immediately available. final ResolvedType type; /// The column constraints set on this column. /// /// See also: /// - https://www.sqlite.org/syntax/column-constraint.html final List constraints; /// The table this column belongs to. Table table; TableColumn(this.name, this.type, {this.constraints = const []}); } /// 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}); } lib/src/analysis/schema/from_create_table.dart0000644000175000017500000000263413527467305021466 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, ); } 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, constraints: definition.constraints, ); } /// 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.dart0000644000175000017500000000613013507167165020144 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 as 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; final collected = []; while (scope != null) { collected.addAll( scope._references.values.expand((list) => list).whereType()); scope = scope.parent; } return collected; } } lib/src/analysis/schema/table.dart0000644000175000017500000000266613527467305017125 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 { /// 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; /// Constructs a table from the known [name] and [resolvedColumns]. Table( {@required this.name, this.resolvedColumns, this.withoutRowId = false, this.tableConstraints = const []}) { for (var column in resolvedColumns) { column.table = this; } } } lib/src/analysis/steps/column_resolver.dart0000644000175000017500000001030113527467305021133 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 visitUpdateStatement(UpdateStatement e) { final table = _resolveTableReference(e.table); 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: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, relevantNode: r, message: 'The table ${r.tableName} could not be found', )); }); return r.resolved = resolvedTable; } } lib/src/analysis/steps/reference_finder.dart0000644000175000017500000001047613527467305021217 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Walks the AST and /// - attaches the global scope containing table names and builtin functions /// - creates [ReferenceScope] 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. class ReferenceFinder extends RecursiveVisitor { final ReferenceScope globalScope; final List _foundVariables = []; ReferenceFinder({@required this.globalScope}); 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); } 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.dart0000644000175000017500000000423213527467305021602 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) { 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) { 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.dart0000644000175000017500000000116213507167165020623 0ustar00pubpub00000000000000part of '../analysis.dart'; /// Resolves the type of columns in a select statement and the type of /// expressions appearing in a select statement. 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); } } 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.dart0000644000175000017500000003373613527467305017605 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; } ResolveResult resolveOrInfer(Typeable t) { if (t is Column) { return resolveColumn(t); } else if (t is Variable) { return inferType(t); } 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 resolveExpression(column.expression); } 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 TupleExpression) { 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)); } 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) => node is Expression && node != argument); final resolved = resolveExpression(relevant as Expression); // 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 TupleExpression || 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.dart0000644000175000017500000002043213527467305014320 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'; part 'clauses/limit.dart'; part 'clauses/ordering.dart'; part 'common/queryables.dart'; part 'common/renamable.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/tuple.dart'; part 'expressions/variables.dart'; part 'schema/column_definition.dart'; part 'schema/table_definition.dart'; part 'statements/create_table.dart'; part 'statements/delete.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 { /// 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 last position that belongs to node, exclusive. Not set for all nodes. int get lastPosition => last.span.end.offset; FileSpan get span => first.span.expand(last.span); /// 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; } } /// 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; } } 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; } /// 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 visitResultColumn(ResultColumn 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(TupleExpression 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); } /// 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(TupleExpression 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 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); @protected T visitChildren(AstNode e) { for (var child in e.childNodes) { child.accept(this); } return null; } } lib/src/ast/clauses/limit.dart0000644000175000017500000000101013506466600016267 0ustar00pubpub00000000000000part of '../ast.dart'; class Limit extends AstNode { 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.dart0000644000175000017500000000156313527467305017005 0ustar00pubpub00000000000000part of '../ast.dart'; class OrderBy extends AstNode { 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 { 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.dart0000644000175000017500000001004313507167165017171 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/expressions/aggregate.dart0000644000175000017500000001435713527467305020052 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 OrderBy 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.dart0000644000175000017500000000355413527467305017746 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.dart0000644000175000017500000000150213506466600020040 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; 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; } } lib/src/ast/expressions/simple.dart0000644000175000017500000000762013512315623017375 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; final Expression inside; InExpression({this.not = false, @required this.left, @required this.inside}); @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; TupleExpression get asTuple { return TupleExpression(expressions: [expression]); } } 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/tuple.dart0000644000175000017500000000101213507167165017234 0ustar00pubpub00000000000000part of '../ast.dart'; /// A tuple of values. For instance, in `SELECT * FROM t WHERE id IN (1,2,3)`, /// the `(1,2,3)` is a tuple. class TupleExpression extends Expression { /// The expressions appearing in this tuple. final List expressions; TupleExpression({@required this.expressions}); @override T accept(AstVisitor visitor) => visitor.visitTuple(this); @override Iterable get childNodes => expressions; @override bool contentEquals(TupleExpression other) => true; } lib/src/ast/expressions/variables.dart0000644000175000017500000000166013507167165020064 0ustar00pubpub00000000000000part of '../ast.dart'; mixin Variable on Expression { int resolvedIndex; } /// A "?" or "?123" variable placeholder class NumberedVariable extends Expression with Variable { final Token questionMark; final int explicitIndex; NumberedVariable(this.questionMark, this.explicitIndex); @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 String name; ColonNamedVariable(this.name); @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/schema/column_definition.dart0000644000175000017500000001052513527467305020500 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; 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; } } /// 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, }) { 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 { 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; 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]; } 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.dart0000644000175000017500000000167013527467305020335 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 { final bool ifNotExists; final String tableName; final List columns; final List tableConstraints; final bool withoutRowId; CreateTableStatement( {this.ifNotExists = false, @required this.tableName, this.columns = const [], this.tableConstraints = const [], this.withoutRowId = false}); @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; } } lib/src/ast/statements/delete.dart0000644000175000017500000000066513527467305017170 0ustar00pubpub00000000000000part of '../ast.dart'; class DeleteStatement extends Statement with CrudStatement { final TableReference from; 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/select.dart0000644000175000017500000000512413527467305017200 0ustar00pubpub00000000000000part of '../ast.dart'; class SelectStatement extends Statement with CrudStatement, ResultSet { final bool distinct; final List columns; final List from; final Expression where; final GroupBy groupBy; final List windowDeclarations; final OrderBy orderBy; final Limit limit; /// 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; 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; } } 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 } } lib/src/ast/statements/statement.dart0000644000175000017500000000043513527467305017725 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Statement extends AstNode {} /// Marker mixin for statements that read from an existing table structure. mixin CrudStatement on Statement {} /// Marker mixin for statements that change the table structure. mixin SchemaStatement on Statement {} lib/src/ast/statements/update.dart0000644000175000017500000000254313527467305017205 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 { final FailureMode or; final TableReference table; final List set; 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/sql_engine.dart0000644000175000017500000001010113527467305016323 0ustar00pubpub00000000000000import 'package:sqlparser/src/analysis/analysis.dart'; import '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'; class SqlEngine { /// All tables registered with [registerTable]. final List
knownTables = []; SqlEngine(); /// 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]. List tokenize(String source) { final scanner = Scanner(source); 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 parser = Parser(tokens); final stmt = parser.statement(); return ParseResult._(stmt, parser.errors, sql); } /// Parses multiple sql statements, separated by a semicolon. All /// [ParseResult] entries will have the same [ParseResult.errors], but the /// [ParseResult.sql] will only refer to the substring creating a statement. List parseMultiple(String sql) { final tokens = tokenize(sql); final parser = Parser(tokens); final stmts = parser.statements(); return stmts.map((statement) { final first = statement.firstPosition; final last = statement.lastPosition; final source = sql.substring(first, last); return ParseResult._(statement, parser.errors, source); }).toList(); } /// 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; const SetParentVisitor().startAtRoot(node); final context = AnalysisContext(node, result.sql); final scope = _constructRootScope(); try { ReferenceFinder(globalScope: scope).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. } return 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; /// 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; ParseResult._(this.rootNode, this.errors, this.sql); } lib/src/reader/parser/crud.dart0000644000175000017500000003547213527467305016447 0ustar00pubpub00000000000000part of 'parser.dart'; mixin CrudParser on ParserBase { @override SelectStatement select() { 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); } /// 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 = select(); _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 tableName = (_previous as IdentifierToken).identifier; final alias = _as(); return TableReference(tableName, alias?.identifier); } 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; } OrderBy _orderBy() { if (_matchOne(TokenType.order)) { _consume(TokenType.by, 'Expected "BY" after "ORDER" token'); final terms = []; do { terms.add(_orderingTerm()); } while (_matchOne(TokenType.comma)); return OrderBy(terms: terms); } return null; } OrderingTerm _orderingTerm() { final expr = expression(); return OrderingTerm(expression: expr, orderingMode: _orderingModeOrNull()); } @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. Limit _limit() { if (!_matchOne(TokenType.limit)) return null; // 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); } else if (_matchOne(TokenType.offset)) { final separator = _previous; final offset = expression(); return Limit(count: first, offsetSeparator: separator, offset: offset); } else { return Limit(count: first); } } DeleteStatement _deleteStmt() { if (!_matchOne(TokenType.delete)) return null; _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); } UpdateStatement _update() { if (!_matchOne(TokenType.update)) return null; 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)); } while (_matchOne(TokenType.comma)); final where = _where(); return UpdateStatement( or: failureMode, table: table, set: set, where: where); } @override WindowDefinition _windowDefinition() { _consume(TokenType.leftParen, 'Expected opening parenthesis'); final leftParen = _previous; String baseWindowName; OrderBy 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.dart0000644000175000017500000002754513527467305020076 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 base = _check(TokenType.when) ? null : _or(); final whens = []; Expression $else; while (_matchOne(TokenType.when)) { final whenExpr = _or(); _consume(TokenType.then, 'Expected THEN'); final then = _or(); whens.add(WhenComponent(when: whenExpr, then: then)); } if (_matchOne(TokenType.$else)) { $else = _or(); } _consume(TokenType.end, 'Expected END to finish the case operator'); return CaseExpression(whens: whens, base: base, elseExpr: $else); } 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); } 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); var inside = _equals(); if (inside is Parentheses) { // if we have something like x IN (3), then (3) is a tuple and not a // parenthesis. We can only know this from the context unfortunately inside = (inside as Parentheses).asTuple; } return InExpression(left: left, inside: inside, not: not); } 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 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); } 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()); } else { expression = BinaryExpression(expression, operator, _comparison()); } } 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); } 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); } else if (_matchOne(TokenType.exists)) { _consume( TokenType.leftParen, 'Expected opening parenthesis after EXISTS'); final selectStmt = select(); _consume(TokenType.rightParen, 'Expected closing paranthesis to finish EXISTS expression'); return ExistsExpression(select: selectStmt); } 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 token = _advance(); final type = token.type; switch (type) { case TokenType.leftParen: // Opening brackets could be three things: An inner select statement // (SELECT ...), a parenthesised expression, or a tuple of expressions // (a, b, c). final left = token; if (_peek.type == TokenType.select) { final stmt = select(); _consume(TokenType.rightParen, 'Expected a closing bracket'); return SubQuery(select: stmt); } else { // alright, it's either a tuple or just parenthesis. A tuple can be // empty, so if the next statement is the closing bracket we're done if (_matchOne(TokenType.rightParen)) { return TupleExpression(expressions: [])..setSpan(left, _previous); } final expr = expression(); // Are we witnessing a tuple? if (_check(TokenType.comma)) { // we are, add expressions as long as we see commas final exprs = [expr]; while (_matchOne(TokenType.comma)) { exprs.add(expression()); } _consume(TokenType.rightParen, 'Expected a closing bracket'); return TupleExpression(expressions: exprs); } else { // we aren't, so that'll just be parentheses. _consume(TokenType.rightParen, 'Expected a closing bracket'); return Parentheses(left, expr, token); } } break; case TokenType.identifier: // could be table.column, function(...) or just column final first = token as IdentifierToken; if (_matchOne(TokenType.dot)) { final second = _consume(TokenType.identifier, 'Expected a column name here') as IdentifierToken; 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); } break; case TokenType.questionMark: final mark = token; if (_matchOne(TokenType.numberLiteral)) { final number = _previous; return NumberedVariable(mark, _parseNumber(number.lexeme).toInt()) ..setSpan(mark, number); } else { return NumberedVariable(mark, null)..setSpan(mark, mark); } break; case TokenType.colon: final colon = token; final identifier = _consume(TokenType.identifier, 'Expected an identifier for the named variable') as IdentifierToken; final content = identifier.identifier; return ColonNamedVariable(':$content')..setSpan(colon, identifier); default: break; } // nothing found -> issue error. Step back to revert the _advance() above _stepBack(); _error('Could not parse this expression'); } 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); } } 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.dart0000644000175000017500000001027613527467305017001 0ustar00pubpub00000000000000import 'package:meta/meta.dart'; import 'package:sqlparser/src/ast/ast.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 = []; int _current = 0; ParserBase(this.tokens); 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) { for (var type in types) { if (_check(type)) { _advance(); return true; } } return false; } bool _matchOne(TokenType 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; } Token _advance() { if (!_isAtEnd) { _current++; } return _previous; } /// Steps back a token. This needs to be used very carefully. We basically /// only use it in [ExpressionParser._primary] because we unconditionally /// [_advance] in there and we'd like to report more accurate errors when no /// matching token was found. void _stepBack() { if (_current != null) { _current--; } } @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); } IdentifierToken _consumeIdentifier(String message) { return _consume(TokenType.identifier, message) as IdentifierToken; } // Common operations that we are referenced very often Expression expression(); /// Parses a [SelectStatement], or returns null if there is no select token /// after the current position. /// /// See also: /// https://www.sqlite.org/lang_select.html SelectStatement select(); Literal _literalOrNull(); OrderingMode _orderingModeOrNull(); /// https://www.sqlite.org/syntax/window-defn.html WindowDefinition _windowDefinition(); } // todo better error handling and synchronisation, like it's done here: // https://craftinginterpreters.com/parsing-expressions.html#synchronizing-a-recursive-descent-parser class Parser extends ParserBase with ExpressionParser, SchemaParser, CrudParser { Parser(List tokens) : super(tokens); Statement statement({bool expectEnd = true}) { final first = _peek; final stmt = select() ?? _deleteStmt() ?? _update() ?? _createTable(); if (stmt == null) { _error('Expected a sql statement to start here'); } _matchOne(TokenType.semicolon); if (!_isAtEnd && expectEnd) { _error('Expected the statement to finish here'); } return stmt..setSpan(first, _previous); } List statements() { final stmts = []; while (!_isAtEnd) { stmts.add(statement(expectEnd: false)); } return stmts; } } lib/src/reader/parser/schema.dart0000644000175000017500000002404513527467305016744 0ustar00pubpub00000000000000part of 'parser.dart'; mixin SchemaParser on ParserBase { CreateTableStatement _createTable() { if (!_matchOne(TokenType.create)) return null; final first = _previous; _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 _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)); _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; } return CreateTableStatement( ifNotExists: ifNotExists, tableName: tableIdentifier.identifier, withoutRowId: withoutRowId, columns: columns, tableConstraints: tableConstraints, )..setSpan(first, _previous); } ColumnDefinition _columnDefinition() { final name = _consume(TokenType.identifier, 'Expected a column name') as IdentifierToken; final typeName = _typeName(); 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); } String _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 typeNameBuilder = StringBuffer(_previous.lexeme); if (_matchOne(TokenType.leftParen)) { typeNameBuilder.write('('); const inBrackets = [ TokenType.identifier, TokenType.comma, TokenType.numberLiteral ]; while (_match(inBrackets)) { typeNameBuilder..write(' ')..write(_previous.lexeme); } _consume(TokenType.rightParen, 'Expected closing paranthesis to finish type name'); } return typeNameBuilder.toString(); } ColumnConstraint _columnConstraint({bool orNull = false}) { final first = _peek; final resolvedName = _constraintNameOrNull(); if (_matchOne(TokenType.primary)) { _consume(TokenType.key, 'Expected KEY to complete PRIMARY KEY clause'); final mode = _orderingModeOrNull(); final conflict = _conflictClauseOrNull(); final hasAutoInc = _matchOne(TokenType.autoincrement); return PrimaryKeyColumn(resolvedName, autoIncrement: hasAutoInc, mode: mode, onConflict: conflict) ..setSpan(first, _previous); } if (_matchOne(TokenType.not)) { _consume(TokenType.$null, 'Expected NULL to complete NOT NULL'); return NotNull(resolvedName, onConflict: _conflictClauseOrNull()) ..setSpan(first, _previous); } 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); } // 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() { 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, }; 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; while (_matchOne(TokenType.on)) { 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.dart0000644000175000017500000002036713527467305017656 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; 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) : _file = SourceFile.fromString(source); List scanTokens() { while (!_isAtEnd) { _startOffset = _currentOffset; _scanToken(); } final endSpan = _file.span(source.length); tokens.add(Token(TokenType.eof, endSpan)); 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 '-': _addToken(TokenType.minus); break; case '*': _addToken(TokenType.star); break; case '/': _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 '?': _addToken(TokenType.questionMark); break; case ':': _addToken(TokenType.colon); 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 ' ': case '\t': case '\n': // ignore whitespace break; default: if (isDigit(char)) { _numeric(char); } else if (canStartColumnName(char)) { _identifier(); } else { errors.add(TokenizerError('Unexpected character.', _currentLocation)); } break; } } 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)) { _addToken(keywords[text]); } else { tokens.add(IdentifierToken(false, _currentSpan)); } } } } lib/src/reader/tokenizer/token.dart0000644000175000017500000001237013527467305017340 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, questionMark, colon, // todo at and dollarSign are currently not used at, dollarSign, stringLiteral, numberLiteral, $true, $false, $null, currentTime, currentDate, currentTimestamp, identifier, select, delete, update, 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, create, table, $if, without, rowid, constraint, autoincrement, primary, foreign, key, unique, check, $default, conflict, references, cascade, restrict, no, action, semicolon, eof, } const Map keywords = { 'SELECT': TokenType.select, '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, }; class Token { final TokenType type; final FileSpan span; String get lexeme => span.text; const 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; const 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; String get identifier { if (escaped) { return lexeme.substring(1, lexeme.length - 1); } else { return lexeme; } } const IdentifierToken(this.escaped, FileSpan span) : super(TokenType.identifier, 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"); } } mono_pkg.yaml0000644000175000017500000000022313527467305013222 0ustar00pubpub00000000000000dart: - stable stages: - analyze: - dartanalyzer: --fatal-infos --fatal-warnings lib/ test/ - dartfmt - unit_test: - test pubspec.yaml0000644000175000017500000000111413527467305013052 0ustar00pubpub00000000000000name: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.2.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/reference_resolver_test.dart0000644000175000017500000000623713527467305021134 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 orderingTerm = select.orderBy.terms.single.expression as Reference; final resolved = orderingTerm.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.dart0000644000175000017500000000470713527467305020157 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 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/analysis/variable_indexing_test.dart0000644000175000017500000000145713507167165020725 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; 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/parser/create_table_test.dart0000644000175000017500000000664513527467305017343 0ustar00pubpub00000000000000import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:test_core/test_core.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/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.dart0000644000175000017500000000705413512315623017110 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(token(TokenType.questionMark), null), token(TokenType.star), NumberedVariable(token(TokenType.questionMark), 3), ), token(TokenType.plus), NumberedVariable(token(TokenType.questionMark), 2), ), token(TokenType.doubleEqual), ColonNamedVariable(':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), ], ), ), ), '(1, 2, 3)': TupleExpression( expressions: [ for (var i = 1; i <= 3; i++) NumericLiteral(i, token(TokenType.numberLiteral)), ], ), "'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), ), ), }; 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(); enforceEqual(expression, expected); }); }); }); } test/parser/partition_test.dart0000644000175000017500000000426513527467305016736 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/from_test.dart0000644000175000017500000000465513527467305017152 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.dart0000644000175000017500000000303513527467305017612 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: TupleExpression(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.dart0000644000175000017500000000145613527467305015025 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); } IdentifierToken identifier(String content) { final fakeFile = SourceFile.fromString(content); return IdentifierToken(false, fakeFile.span(0)); } void testStatement(String sql, AstNode expected) { final parsed = SqlEngine().parse(sql).rootNode; enforceEqual(parsed, expected); } void testAll(Map testCases) { testCases.forEach((sql, expected) { test('with $sql', () { testStatement(sql, expected); }); }); } test/scanner/single_token_tests.dart0000644000175000017500000000265413527467305017726 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...'); }