.gitignore0000644000175000017500000000035413506466600012514 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/ CHANGELOG.md0000644000175000017500000000124413512160211012316 0ustar00pubpub00000000000000## 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.md0000644000175000017500000000662013507167165012012 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, only `INSERT` statements are not supported, but they will be soon - Windowing is not supported yet - Compound select statements (`UNION` / `INTERSECT`) are not supported yet - Common table expressions are not supported - Some advanced expressions, like `COLLATE` or `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.dart0000644000175000017500000000035513507167165014170 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/tokenizer/token.dart' show CumulatedTokenizerException; lib/src/analysis/analysis.dart0000644000175000017500000000104113507167165016402 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/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.dart0000644000175000017500000000161313507167165017321 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 table this column belongs to. Table table; TableColumn(this.name, this.type); } /// 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/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.dart0000644000175000017500000000223513507167165017114 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; /// Constructs a table from the known [name] and [resolvedColumns]. Table({@required this.name, this.resolvedColumns}) { for (var column in resolvedColumns) { column.table = this; } } } lib/src/analysis/steps/column_resolver.dart0000644000175000017500000000760513507167165021147 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, so we don't _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); usedColumns.add( ExpressionColumn(name: name, expression: resultColumn.expression), ); } } s.resolvedColumns = usedColumns; s.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.dart0000644000175000017500000001031713507167165021210 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; } 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.dart0000644000175000017500000000365013507167165021604 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); } } 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.dart0000644000175000017500000003045713507167165017601 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 FunctionExpression) { 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); } ResolveResult resolveFunctionCall(FunctionExpression call) { return _cache((FunctionExpression call) { List parameters; final sqlParameters = call.parameters; if (sqlParameters is ExprFunctionParameters) { parameters = sqlParameters.parameters; } else if (sqlParameters is StarFunctionParameter) { parameters = call.scope.availableColumns; } 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': 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': 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 '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 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); } 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 FunctionExpression) { 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.dart0000644000175000017500000001605313507167165014323 0ustar00pubpub00000000000000import 'package:collection/collection.dart'; import 'package:meta/meta.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/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 '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; /// 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 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 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 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 visitUnaryExpression(UnaryExpression 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.dart0000644000175000017500000000146213506466600016775 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; OrderingTerm({this.expression, this.orderingMode = OrderingMode.ascending}); @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/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.dart0000644000175000017500000000307713506466600017740 0ustar00pubpub00000000000000part of '../ast.dart'; class FunctionExpression extends Expression with ReferenceOwner { final String name; 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.dart0000644000175000017500000000762013511421713017372 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/statements/delete.dart0000644000175000017500000000064213507167165017162 0ustar00pubpub00000000000000part of '../ast.dart'; class DeleteStatement extends Statement { 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.dart0000644000175000017500000000463213507167165017202 0ustar00pubpub00000000000000part of '../ast.dart'; class SelectStatement extends Statement with ResultSet { final bool distinct; final List columns; final List from; final Expression where; final GroupBy groupBy; 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.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, 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.dart0000644000175000017500000000010413507167165017715 0ustar00pubpub00000000000000part of '../ast.dart'; abstract class Statement extends AstNode {} lib/src/ast/statements/update.dart0000644000175000017500000000252013507167165017177 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 { 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.dart0000644000175000017500000000527413507167165016341 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; } /// Parses the [sql] statement. At the moment, only SELECT statements are /// supported. ParseResult parse(String sql) { final scanner = Scanner(sql); final tokens = scanner.scanTokens(); if (scanner.errors.isNotEmpty) { throw CumulatedTokenizerException(scanner.errors); } final parser = Parser(tokens); final stmt = parser.statement(); return ParseResult._(stmt, parser.errors); } /// Parses and analyzes the [sql] statement, which at the moment has to be a /// select 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); final node = result.rootNode; const SetParentVisitor().startAtRoot(node); final context = AnalysisContext(node, sql); final scope = _constructRootScope(); try { ReferenceFinder(globalScope: scope).start(node); 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; ParseResult._(this.rootNode, this.errors); } 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.dart0000644000175000017500000005632013511421713016763 0ustar00pubpub00000000000000import 'package:meta/meta.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; part 'num_parser.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}'); } } // todo better error handling and synchronisation, like it's done here: // https://craftinginterpreters.com/parsing-expressions.html#synchronizing-a-recursive-descent-parser class Parser { final List tokens; final List errors = []; int _current = 0; Parser(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(List 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; } @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); } Statement statement() { final stmt = select() ?? _deleteStmt() ?? _update(); _matchOne(TokenType.semicolon); if (!_isAtEnd) { _error('Expected the statement to finish here'); } return stmt; } /// 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() { 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 orderBy = _orderBy(); final limit = _limit(); return SelectStatement( distinct: distinct, columns: resultColumns, from: from, where: where, groupBy: groupBy, 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; } OrderBy _orderBy() { if (_match(const [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(); if (_match(const [TokenType.asc, TokenType.desc])) { final mode = _previous.type == TokenType.asc ? OrderingMode.ascending : OrderingMode.descending; return OrderingTerm(expression: expr, orderingMode: mode); } return OrderingTerm(expression: expr); } /// 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 reference = _primary() as Reference; _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); } /* We parse expressions here. * Operators have the following precedence: * - + ~ NOT (unary) * || (concatenation) * * / % * + - * << >> & | * < <= > >= * = == != <> IS IS NOT IN LIKE GLOB MATCH REGEXP * AND * OR * We also treat expressions in parentheses and literals with the highest * priority. Parsing methods are written in ascending precedence, and each * parsing method calls the next higher precedence if unsuccessful. * https://www.sqlite.org/lang_expr.html * */ 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; } Expression _primary() { final token = _advance(); final type = token.type; switch (type) { case TokenType.numberLiteral: return NumericLiteral(_parseNumber(token.lexeme), token); case TokenType.stringLiteral: return StringLiteral(token as StringLiteralToken); case TokenType.$null: return NullLiteral(token); case TokenType.$true: return BooleanLiteral.withTrue(token); case TokenType.$false: return BooleanLiteral.withFalse(token); // todo CURRENT_TIME, CURRENT_DATE, CURRENT_TIMESTAMP 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'); 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 _error('Could not parse this expression'); } FunctionParameters _functionParameters() { if (_matchOne(TokenType.star)) { return const StarFunctionParameter(); } final distinct = _matchOne(TokenType.distinct); final parameters = []; while (_peek.type != TokenType.rightParen) { parameters.add(expression()); } return ExprFunctionParameters(distinct: distinct, parameters: parameters); } } lib/src/reader/tokenizer/scanner.dart0000644000175000017500000002023713507167165017651 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 '=': _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.', SourceLocation(_currentOffset))); } 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.dart0000644000175000017500000000757013511421713017330 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, rollback, abort, replace, fail, ignore, set, 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, }; 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"); } } pubspec.yaml0000644000175000017500000000071013512160211013027 0ustar00pubpub00000000000000name: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.1.2 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/analysis/data.dart0000644000175000017500000000105213507167165015114 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: 'table', resolvedColumns: [anotherId, dateTime], ); test/analysis/reference_resolver_test.dart0000644000175000017500000000213413507167165021123 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.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/analysis/type_resolver_test.dart0000644000175000017500000000347413507167165020156 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 table ON demo.id = table.id WHERE date = ?': const ResolveResult( ResolvedType(type: BasicType.int, hint: IsDateTime())), }; 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/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/parser/delete_test.dart0000644000175000017500000000110313507167165016152 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 table WHERE id = 5', DeleteStatement( from: TableReference('table', null), where: BinaryExpression( Reference(columnName: 'id'), token(TokenType.equal), NumericLiteral( 5, token(TokenType.numberLiteral), ), ), ), ); }); } test/parser/expression_test.dart0000644000175000017500000000705413511421713017105 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/select/from_test.dart0000644000175000017500000000466513507167165017152 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 table').rootNode as SelectStatement; enforceEqual(stmt.from.single, TableReference('table', null)); }); test('from more than one table', () { final stmt = SqlEngine() .parse('SELECT * FROM table AS test, table2') .rootNode as SelectStatement; _enforceFrom( stmt, [ TableReference('table', '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.dart0000644000175000017500000000275213507167165017616 0ustar00pubpub00000000000000import 'package:sqlparser/src/ast/ast.dart'; import '../utils.dart'; final Map testCases = { 'SELECT table.*, *, 1 as name WHERE 1 ORDER BY name LIMIT 3 OFFSET 5': SelectStatement( columns: [ StarResultColumn('table'), 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')), ]), limit: Limit( count: NumericLiteral(3, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(5, token(TokenType.numberLiteral)), ), ), 'SELECT table.*, (SELECT * FROM table2) FROM table': SelectStatement( columns: [ StarResultColumn('table'), ExpressionResultColumn( expression: SubQuery( select: SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('table2', null)], ), ), ), ], from: [ TableReference('table', null), ], ), 'SELECT * FROM table WHERE id IN ()': SelectStatement( columns: [StarResultColumn(null)], from: [TableReference('table', 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.dart0000644000175000017500000000326513511421713017303 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.dart0000644000175000017500000000154513507167165020006 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 table ORDER BY -a, b DESC') .rootNode as SelectStatement; enforceEqual( parsed.orderBy, OrderBy( terms: [ OrderingTerm( orderingMode: OrderingMode.ascending, expression: UnaryExpression( token(TokenType.minus), Reference(columnName: 'a'), ), ), OrderingTerm( orderingMode: OrderingMode.descending, expression: Reference(columnName: 'b'), ), ], ), ); }); } test/parser/update_test.dart0000644000175000017500000000125213507167165016177 0ustar00pubpub00000000000000import 'package:test/test.dart'; import 'package:sqlparser/sqlparser.dart'; import 'utils.dart'; final testCases = { 'UPDATE OR ROLLBACK table SET a = NULL, b = c WHERE d': UpdateStatement( or: FailureMode.rollback, table: TableReference('table', 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.dart0000644000175000017500000000115113510727135015005 0ustar00pubpub00000000000000import '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); } 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.dart0000644000175000017500000000261013506466600017710 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, "'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); }); }