lib/sqlparser.dart 644 0 0 1204 14206504764 12325 0ustar0 pubpub/// An sql parser and analyzer for Dart. library sqlparser; export 'src/analysis/analysis.dart'; export 'src/analysis/types/join_analysis.dart'; export 'src/ast/ast.dart'; export 'src/engine/module/fts5.dart' show Fts5Extension; export 'src/engine/module/json1.dart' show Json1Extension; export 'src/engine/module/math.dart' show BuiltInMathExtension; export 'src/engine/module/module.dart'; export 'src/engine/options.dart'; export 'src/engine/sql_engine.dart'; export 'src/reader/parser.dart' show ParsingError; export 'src/reader/syntactic_entity.dart'; export 'src/reader/tokenizer/token.dart' hide keywords, driftKeywords, isKeyword; lib/utils/node_to_text.dart 644 0 0 102053 14211621611 14173 0ustar0 pubpub/// Library to convert AST nodes back to text. /// /// See the [NodeToText] extension for details. library utils.node_to_text; import 'package:charcode/charcode.dart'; import 'package:sqlparser/sqlparser.dart'; class NodeSqlBuilder extends AstVisitor { final StringSink buffer; /// Whether we need to insert a space before writing the next identifier. bool needsSpace = false; NodeSqlBuilder([StringSink? buffer]) : buffer = buffer ?? StringBuffer(); /// Writes a space character if [needsSpace] is set. /// /// This also resets [needsSpace] to `false`. void spaceIfNeeded() { if (needsSpace) { needsSpace = false; _space(); } } @override void visitAggregateFunctionInvocation( AggregateFunctionInvocation e, void arg) { symbol(e.name); symbol('('); visit(e.parameters, arg); symbol(')'); if (e.filter != null) { _keyword(TokenType.filter); symbol('(', spaceBefore: true); _keyword(TokenType.where); visit(e.filter!, arg); symbol(')', spaceAfter: true); } } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { visitAggregateFunctionInvocation(e, arg); if (e.windowDefinition != null) { _keyword(TokenType.over); visit(e.windowDefinition!, arg); } else if (e.windowName != null) { _keyword(TokenType.over); identifier(e.windowName!); } } @override void visitBeginTransaction(BeginTransactionStatement e, void arg) { _keyword(TokenType.begin); switch (e.mode) { case TransactionMode.none: break; case TransactionMode.deferred: _keyword(TokenType.deferred); break; case TransactionMode.immediate: _keyword(TokenType.immediate); break; case TransactionMode.exclusive: _keyword(TokenType.exclusive); break; } } @override void visitBetweenExpression(BetweenExpression e, void arg) { visit(e.check, arg); if (e.not) { _keyword(TokenType.not); } _keyword(TokenType.between); visit(e.lower, arg); _keyword(TokenType.and); visit(e.upper, arg); } @override void visitBinaryExpression(BinaryExpression e, void arg) { visit(e.left, arg); final operatorSymbol = const { TokenType.doublePipe: '||', TokenType.star: '*', TokenType.slash: '/', TokenType.percent: '%', TokenType.plus: '+', TokenType.minus: '-', TokenType.shiftLeft: '<<', TokenType.shiftRight: '>>', TokenType.ampersand: '&', TokenType.pipe: '|', TokenType.less: '<', TokenType.lessEqual: '<=', TokenType.more: '>', TokenType.moreEqual: '>=', TokenType.equal: '=', TokenType.doubleEqual: '==', TokenType.exclamationEqual: '!=', TokenType.lessMore: '<>', TokenType.dashRangle: '->', TokenType.dashRangleRangle: '->>', }[e.operator.type]; if (operatorSymbol != null) { symbol(operatorSymbol, spaceBefore: true, spaceAfter: true); } else { _keyword(e.operator.type); } visit(e.right, arg); } void _writeStatements(Iterable statements) { for (final stmt in statements) { visit(stmt, null); symbol(';'); } } @override void visitBlock(Block block, void arg) { _keyword(TokenType.begin); _writeStatements(block.statements); _keyword(TokenType.end); } @override void visitBooleanLiteral(BooleanLiteral e, void arg) { _keyword(e.value ? TokenType.$true : TokenType.$false); } @override void visitCaseExpression(CaseExpression e, void arg) { _keyword(TokenType.$case); visitNullable(e.base, arg); visitList(e.whens, arg); final elseExpr = e.elseExpr; if (elseExpr != null) { _keyword(TokenType.$else); visit(elseExpr, arg); } _keyword(TokenType.end); } @override void visitCastExpression(CastExpression e, void arg) { _keyword(TokenType.cast); symbol('('); visit(e.operand, arg); _keyword(TokenType.as); symbol(e.typeName, spaceBefore: true); symbol(')', spaceAfter: true); } @override void visitCollateExpression(CollateExpression e, void arg) { visit(e.inner, arg); _keyword(TokenType.collate); identifier(e.collation); } @override void visitColumnConstraint(ColumnConstraint e, void arg) { if (e.name != null) { _keyword(TokenType.constraint); identifier(e.name!); } e.when(primaryKey: (primaryKey) { _keyword(TokenType.primary); _keyword(TokenType.key); _orderingMode(primaryKey.mode); _conflictClause(primaryKey.onConflict); if (primaryKey.autoIncrement) _keyword(TokenType.autoincrement); }, notNull: (notNull) { _keyword(TokenType.not); _keyword(TokenType.$null); _conflictClause(notNull.onConflict); }, unique: (unique) { _keyword(TokenType.unique); _conflictClause(unique.onConflict); }, check: (check) { _keyword(TokenType.check); symbol('(', spaceBefore: true); visit(check.expression, arg); symbol(')', spaceAfter: true); }, isDefault: (def) { _keyword(TokenType.$default); final expr = def.expression; if (expr is Literal) { visit(expr, arg); } else { symbol('(', spaceBefore: true); visit(expr, arg); symbol(')', spaceAfter: true); } }, collate: (collate) { _keyword(TokenType.collate); identifier(collate.collation); }, foreignKey: (foreignKey) { visit(foreignKey.clause, arg); }, generatedAs: (generatedAs) { _keyword(TokenType.generated); _keyword(TokenType.always); _keyword(TokenType.as); symbol('(', spaceBefore: true); visit(generatedAs.expression, arg); symbol(')', spaceAfter: true); if (generatedAs.stored) { _keyword(TokenType.stored); } else { _keyword(TokenType.virtual); } }); } @override void visitColumnDefinition(ColumnDefinition e, void arg) { identifier(e.columnName); if (e.typeName != null) { symbol(e.typeName!, spaceAfter: true, spaceBefore: true); } visitList(e.constraints, arg); } @override void visitCommitStatement(CommitStatement e, void arg) { _keyword(TokenType.commit); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { identifier(e.cteTableName); if (e.columnNames != null) { symbol('(${e.columnNames!.join(', ')})', spaceAfter: true); } _keyword(TokenType.as); switch (e.materializationHint) { case MaterializationHint.notMaterialized: _keyword(TokenType.not); _keyword(TokenType.materialized); break; case MaterializationHint.materialized: _keyword(TokenType.materialized); break; case null: break; } symbol('(', spaceBefore: true); visit(e.as, arg); symbol(')', spaceAfter: true); } @override void visitCompoundSelectPart(CompoundSelectPart e, void arg) { switch (e.mode) { case CompoundSelectMode.union: _keyword(TokenType.union); break; case CompoundSelectMode.unionAll: _keyword(TokenType.union); _keyword(TokenType.all); break; case CompoundSelectMode.intersect: _keyword(TokenType.intersect); break; case CompoundSelectMode.except: _keyword(TokenType.except); break; } visit(e.select, arg); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { visitNullable(e.withClause, arg); visit(e.base, arg); visitList(e.additional, arg); } @override void visitCreateIndexStatement(CreateIndexStatement e, void arg) { _keyword(TokenType.create); if (e.unique) { _keyword(TokenType.unique); } _keyword(TokenType.$index); _ifNotExists(e.ifNotExists); identifier(e.indexName); _keyword(TokenType.on); visit(e.on, arg); symbol('(', spaceBefore: true); _join(e.columns, ','); symbol(')', spaceAfter: true); _where(e.where); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { _keyword(TokenType.create); _keyword(TokenType.table); _ifNotExists(e.ifNotExists); identifier(e.tableName); symbol('('); _join([...e.columns, ...e.tableConstraints], ','); symbol(')'); if (e.withoutRowId) { _keyword(TokenType.without); _keyword(TokenType.rowid); } if (e.isStrict) { if (e.withoutRowId) symbol(','); _keyword(TokenType.strict); } } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { _keyword(TokenType.create); _keyword(TokenType.trigger); _ifNotExists(e.ifNotExists); identifier(e.triggerName); switch (e.mode) { case TriggerMode.before: _keyword(TokenType.before); break; case TriggerMode.after: _keyword(TokenType.after); break; case TriggerMode.insteadOf: _keyword(TokenType.instead); _keyword(TokenType.of); break; default: // Can happen if e.mode == null break; } visit(e.target, arg); _keyword(TokenType.on); visit(e.onTable, arg); if (e.when != null) { _keyword(TokenType.when); visit(e.when!, arg); } visit(e.action, arg); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { _keyword(TokenType.create); _keyword(TokenType.view); _ifNotExists(e.ifNotExists); identifier(e.viewName); if (e.columns != null) { symbol('(', spaceBefore: true); symbol(e.columns!.join(',')); symbol(')', spaceAfter: true); } _keyword(TokenType.as); visit(e.query, arg); } @override void visitCreateVirtualTableStatement( CreateVirtualTableStatement e, void arg) { _keyword(TokenType.create); _keyword(TokenType.virtual); _keyword(TokenType.table); _ifNotExists(e.ifNotExists); identifier(e.tableName); _keyword(TokenType.using); identifier(e.moduleName); symbol('(${e.argumentContent.join(', ')})'); } @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is DartPlaceholder) { symbol(r'$', spaceBefore: true); symbol(e.name, spaceAfter: true); } else if (e is DeclaredStatement) { identifier(e.identifier.name); if (e.parameters.isNotEmpty) { symbol('('); _join(e.parameters, ','); symbol(')'); } if (e.as != null) { _keyword(TokenType.as); identifier(e.as!); } symbol(':', spaceAfter: true); visit(e.statement, arg); symbol(';'); } else if (e is DriftFile) { for (final stmt in e.statements) { visit(stmt, arg); buffer.write('\n'); needsSpace = false; } } else if (e is ImportStatement) { _keyword(TokenType.import); _stringLiteral(e.importedFile); symbol(';', spaceAfter: true); } else if (e is StatementParameter) { if (e is VariableTypeHint) { if (e.isRequired) _keyword(TokenType.required); visit(e.variable, arg); final typeName = e.typeName; if (typeName != null) { _keyword(TokenType.as); symbol(typeName, spaceBefore: true, spaceAfter: true); } if (e.orNull) { _keyword(TokenType.or); _keyword(TokenType.$null); } } else if (e is DartPlaceholderDefaultValue) { symbol('\$${e.variableName}', spaceAfter: true); symbol('=', spaceBefore: true, spaceAfter: true); visit(e.defaultValue, arg); } else { throw AssertionError('Unknown StatementParameter: $e'); } } else if (e is DriftTableName) { _keyword(e.useExistingDartClass ? TokenType.$with : TokenType.as); identifier(e.overriddenDataClassName); } else if (e is NestedStarResultColumn) { identifier(e.tableName); symbol('.**', spaceAfter: true); } else if (e is NestedQueryColumn) { symbol('LIST('); visit(e.select, arg); symbol(')', spaceAfter: true); } else if (e is TransactionBlock) { visit(e.begin, arg); _writeStatements(e.innerStatements); visit(e.commit, arg); } } @override void visitDefaultValues(DefaultValues e, void arg) { _keyword(TokenType.$default); _keyword(TokenType.$values); } @override void visitDeferrableClause(DeferrableClause e, void arg) { if (e.not) { _keyword(TokenType.not); } _keyword(TokenType.deferrable); switch (e.declaredInitially) { case InitialDeferrableMode.deferred: _keyword(TokenType.initially); _keyword(TokenType.deferred); break; case InitialDeferrableMode.immediate: _keyword(TokenType.initially); _keyword(TokenType.immediate); break; default: // declaredInitially == null, don't do anything break; } } @override void visitDeleteStatement(DeleteStatement e, void arg) { visitNullable(e.withClause, arg); _keyword(TokenType.delete); _from(e.from); _where(e.where); visitNullable(e.returning, arg); } @override void visitDeleteTriggerTarget(DeleteTarget e, void arg) { _keyword(TokenType.delete); } @override void visitDoNothing(DoNothing e, void arg) { _keyword(TokenType.nothing); } @override void visitDoUpdate(DoUpdate e, void arg) { _keyword(TokenType.update); _keyword(TokenType.set); _join(e.set, ','); _where(e.where); } @override void visitExists(ExistsExpression e, void arg) { _keyword(TokenType.exists); symbol('(', spaceBefore: true); visit(e.select, null); symbol(')', spaceAfter: true); } @override void visitExpressionFunctionParameters(ExprFunctionParameters e, void arg) { if (e.distinct) { _keyword(TokenType.distinct); } _join(e.parameters, ','); } @override void visitExpressionResultColumn(ExpressionResultColumn e, void arg) { visit(e.expression, arg); if (e.as != null) { _keyword(TokenType.as); identifier(e.as!); } } @override void visitForeignKeyClause(ForeignKeyClause e, void arg) { _keyword(TokenType.references); visit(e.foreignTable, arg); if (e.columnNames.isNotEmpty) { symbol('('); _join(e.columnNames, ','); symbol(')'); } void referenceAction(ReferenceAction action) { switch (action) { case ReferenceAction.setNull: _keyword(TokenType.set); _keyword(TokenType.$null); break; case ReferenceAction.setDefault: _keyword(TokenType.set); _keyword(TokenType.$default); break; case ReferenceAction.cascade: _keyword(TokenType.cascade); break; case ReferenceAction.restrict: _keyword(TokenType.restrict); break; case ReferenceAction.noAction: _keyword(TokenType.no); _keyword(TokenType.action); break; } } if (e.onUpdate != null) { _keyword(TokenType.on); _keyword(TokenType.update); referenceAction(e.onUpdate!); } if (e.onDelete != null) { _keyword(TokenType.on); _keyword(TokenType.delete); referenceAction(e.onDelete!); } visitNullable(e.deferrable, arg); } @override void visitFrameSpec(FrameSpec e, void arg) { void frameBoundary(FrameBoundary boundary) { void precedingOrFollowing(bool preceding) { if (boundary.isUnbounded) { _keyword(TokenType.unbounded); } else { visit(boundary.offset!, arg); } _keyword(preceding ? TokenType.preceding : TokenType.following); } if (boundary.isCurrentRow) { _keyword(TokenType.current); _keyword(TokenType.row); } else if (boundary.preceding) { precedingOrFollowing(true); } else { precedingOrFollowing(false); } } _keyword(const { FrameType.range: TokenType.range, FrameType.rows: TokenType.rows, FrameType.groups: TokenType.groups, }[e.type!]!); _keyword(TokenType.between); frameBoundary(e.start); _keyword(TokenType.and); frameBoundary(e.end); if (e.excludeMode != null) { _keyword(TokenType.exclude); switch (e.excludeMode!) { case ExcludeMode.noOthers: _keyword(TokenType.no); _keyword(TokenType.others); break; case ExcludeMode.currentRow: _keyword(TokenType.current); _keyword(TokenType.row); break; case ExcludeMode.group: _keyword(TokenType.group); break; case ExcludeMode.ties: _keyword(TokenType.ties); break; } } } @override void visitFunction(FunctionExpression e, void arg) { identifier(e.name); symbol('('); visit(e.parameters, arg); symbol(')', spaceAfter: true); } @override void visitGroupBy(GroupBy e, void arg) { _keyword(TokenType.group); _keyword(TokenType.by); _join(e.by, ','); if (e.having != null) { _keyword(TokenType.having); visit(e.having!, arg); } } @override void visitIndexedColumn(IndexedColumn e, void arg) { visit(e.expression, arg); _orderingMode(e.ordering); } @override void visitInExpression(InExpression e, void arg) { visit(e.left, arg); if (e.not) { _keyword(TokenType.not); } _keyword(TokenType.$in); visit(e.inside, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { visitNullable(e.withClause, arg); final mode = e.mode; if (mode == InsertMode.insert) { _keyword(TokenType.insert); } else if (mode == InsertMode.replace) { _keyword(TokenType.replace); } else { _keyword(TokenType.insert); _keyword(TokenType.or); _keyword(const { InsertMode.insertOrReplace: TokenType.replace, InsertMode.insertOrRollback: TokenType.rollback, InsertMode.insertOrAbort: TokenType.abort, InsertMode.insertOrFail: TokenType.fail, InsertMode.insertOrIgnore: TokenType.ignore, }[mode]!); visitNullable(e.returning, arg); } _keyword(TokenType.into); visit(e.table, arg); if (e.targetColumns.isNotEmpty) { symbol('(', spaceBefore: true); _join(e.targetColumns, ','); symbol(')', spaceAfter: true); } visit(e.source, arg); visitNullable(e.upsert, arg); visitNullable(e.returning, arg); } @override void visitInsertTriggerTarget(InsertTarget e, void arg) { _keyword(TokenType.insert); } @override void visitInvalidStatement(InvalidStatement e, void arg) { throw UnsupportedError( 'InvalidStatement does not have a textual representation'); } @override void visitIsExpression(IsExpression e, void arg) { visit(e.left, arg); _keyword(TokenType.$is); if (e.negated) { _keyword(TokenType.not); } visit(e.right, arg); } @override void visitIsNullExpression(IsNullExpression e, void arg) { visit(e.operand, arg); if (e.negated) { _keyword(TokenType.notNull); } else { _keyword(TokenType.isNull); } } @override void visitJoin(Join e, void arg) { if (e.operator == JoinOperator.comma) { symbol(','); } else { if (e.natural) { _keyword(TokenType.natural); } switch (e.operator) { case JoinOperator.none: break; case JoinOperator.comma: throw AssertionError("Can't happen"); case JoinOperator.left: _keyword(TokenType.left); break; case JoinOperator.leftOuter: _keyword(TokenType.left); _keyword(TokenType.outer); break; case JoinOperator.inner: _keyword(TokenType.inner); break; case JoinOperator.cross: _keyword(TokenType.cross); break; } _keyword(TokenType.join); } visit(e.query, null); final constraint = e.constraint; if (constraint is OnConstraint) { _keyword(TokenType.on); visit(constraint.expression, arg); } else if (constraint is UsingConstraint) { _keyword(TokenType.using); symbol('(${constraint.columnNames.join(', ')})'); } } @override void visitJoinClause(JoinClause e, void arg) { visit(e.primary, arg); visitList(e.joins, arg); } @override void visitLimit(Limit e, void arg) { _keyword(TokenType.limit); visit(e.count, arg); if (e.offset != null) { _keyword(TokenType.offset); visit(e.offset!, arg); } } @override void visitNamedVariable(ColonNamedVariable e, void arg) { // Note: The name already starts with the colon symbol(e.name, spaceBefore: true, spaceAfter: true); } @override void visitNullLiteral(NullLiteral e, void arg) { _keyword(TokenType.$null); } @override void visitNumberedVariable(NumberedVariable e, void arg) { symbol('?', spaceBefore: true, spaceAfter: e.explicitIndex == null); if (e.explicitIndex != null) { symbol(e.explicitIndex.toString(), spaceAfter: true); } } @override void visitNumericLiteral(NumericLiteral e, void arg) { symbol(e.value.toString(), spaceBefore: true, spaceAfter: true); } @override void visitOrderBy(OrderBy e, void arg) { _keyword(TokenType.order); _keyword(TokenType.by); _join(e.terms, ','); } @override void visitOrderingTerm(OrderingTerm e, void arg) { visit(e.expression, arg); _orderingMode(e.orderingMode); if (e.nulls != null) { _keyword(TokenType.nulls); _keyword(const { OrderingBehaviorForNulls.first: TokenType.first, OrderingBehaviorForNulls.last: TokenType.last, }[e.nulls!]!); } } @override void visitParentheses(Parentheses e, void arg) { symbol('('); visit(e.expression, arg); symbol(')'); } @override void visitRaiseExpression(RaiseExpression e, void arg) { _keyword(TokenType.raise); symbol('(', spaceBefore: true); _keyword(const { RaiseKind.ignore: TokenType.ignore, RaiseKind.rollback: TokenType.rollback, RaiseKind.abort: TokenType.abort, RaiseKind.fail: TokenType.fail, }[e.raiseKind]!); if (e.errorMessage != null) { symbol(',', spaceAfter: true); _stringLiteral(e.errorMessage!); } symbol(')', spaceAfter: true); } @override void visitReference(Reference e, void arg) { var didWriteSpaceBefore = false; if (e.schemaName != null) { identifier(e.schemaName!, spaceAfter: false); symbol('.'); didWriteSpaceBefore = true; } if (e.entityName != null) { identifier(e.entityName!, spaceAfter: false, spaceBefore: !didWriteSpaceBefore); symbol('.'); didWriteSpaceBefore = true; } identifier(e.columnName, spaceAfter: true, spaceBefore: !didWriteSpaceBefore); } @override void visitReturning(Returning e, void arg) { _keyword(TokenType.returning); _join(e.columns, ','); } @override void visitSelectInsertSource(SelectInsertSource e, void arg) { visit(e.stmt, arg); } @override void visitSelectStatement(SelectStatement e, void arg) { visitNullable(e.withClause, arg); _keyword(TokenType.select); if (e.distinct) { _keyword(TokenType.distinct); } _join(e.columns, ','); _from(e.from); _where(e.where); visitNullable(e.groupBy, arg); if (e.windowDeclarations.isNotEmpty) { _keyword(TokenType.window); var isFirst = true; for (final declaration in e.windowDeclarations) { if (!isFirst) { symbol(',', spaceAfter: true); } identifier(declaration.name); _keyword(TokenType.as); visit(declaration.definition, arg); isFirst = false; } } visitNullable(e.orderBy, arg); visitNullable(e.limit, arg); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, void arg) { symbol('(', spaceBefore: true); visit(e.statement, arg); symbol(')', spaceAfter: true); if (e.as != null) { _keyword(TokenType.as); identifier(e.as!); } } @override void visitSetComponent(SetComponent e, void arg) { visit(e.column, arg); symbol('=', spaceBefore: true, spaceAfter: true); visit(e.expression, arg); } @override void visitStarFunctionParameter(StarFunctionParameter e, void arg) { symbol('*', spaceAfter: true); } @override void visitStarResultColumn(StarResultColumn e, void arg) { if (e.tableName != null) { identifier(e.tableName!); symbol('.'); } symbol('*', spaceAfter: true, spaceBefore: e.tableName == null); } @override void visitStringComparison(StringComparisonExpression e, void arg) { visit(e.left, arg); if (e.not) { _keyword(TokenType.not); } _keyword(e.operator.type); visit(e.right, arg); if (e.escape != null) { _keyword(TokenType.escape); visit(e.escape!, arg); } } @override void visitStringLiteral(StringLiteral e, void arg) { _stringLiteral(e.value); } @override void visitSubQuery(SubQuery e, void arg) { symbol('(', spaceBefore: true); visit(e.select, arg); symbol(')', spaceAfter: true); } @override void visitTableConstraint(TableConstraint e, void arg) { if (e.name != null) { _keyword(TokenType.constraint); identifier(e.name!); } if (e is KeyClause) { if (e.isPrimaryKey) { _keyword(TokenType.primary); _keyword(TokenType.key); } else { _keyword(TokenType.unique); } symbol('('); _join(e.columns, ','); symbol(')'); _conflictClause(e.onConflict); } else if (e is CheckTable) { _keyword(TokenType.check); symbol('('); visit(e.expression, arg); symbol(')'); } else if (e is ForeignKeyTableConstraint) { _keyword(TokenType.foreign); _keyword(TokenType.key); symbol('('); _join(e.columns, ','); symbol(')'); visit(e.clause, arg); } } @override void visitTableReference(TableReference e, void arg) { if (e.schemaName != null) { identifier(e.schemaName!, spaceAfter: false); symbol('.'); } identifier(e.tableName, spaceBefore: e.schemaName == null); if (e.as != null) { _keyword(TokenType.as); identifier(e.as!); } } @override void visitTableValuedFunction(TableValuedFunction e, void arg) { identifier(e.name); symbol('('); visit(e.parameters, arg); symbol(')'); if (e.as != null) { _keyword(TokenType.as); identifier(e.as!); } } @override void visitTimeConstantLiteral(TimeConstantLiteral e, void arg) { switch (e.kind) { case TimeConstantKind.currentTime: _keyword(TokenType.currentTime); break; case TimeConstantKind.currentDate: _keyword(TokenType.currentDate); break; case TimeConstantKind.currentTimestamp: _keyword(TokenType.currentTimestamp); break; } } @override void visitTuple(Tuple e, void arg) { symbol('(', spaceBefore: true); _join(e.expressions, ','); symbol(')', spaceAfter: true); } @override void visitUnaryExpression(UnaryExpression e, void arg) { switch (e.operator.type) { case TokenType.minus: symbol('-', spaceBefore: true); break; case TokenType.plus: symbol('+', spaceBefore: true); break; case TokenType.tilde: symbol('~', spaceBefore: true); break; case TokenType.not: _keyword(TokenType.not); break; default: throw AssertionError('Unknown unary operator: ${e.operator}'); } visit(e.inner, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { visitNullable(e.withClause, arg); _keyword(TokenType.update); if (e.or != null) { _keyword(TokenType.or); _keyword(const { FailureMode.rollback: TokenType.rollback, FailureMode.abort: TokenType.abort, FailureMode.replace: TokenType.replace, FailureMode.fail: TokenType.fail, FailureMode.ignore: TokenType.ignore, }[e.or!]!); } visit(e.table, arg); _keyword(TokenType.set); _join(e.set, ','); _from(e.from); _where(e.where); visitNullable(e.returning, arg); } @override void visitUpdateTriggerTarget(UpdateTarget e, void arg) { _keyword(TokenType.update); if (e.columnNames.isNotEmpty) { _keyword(TokenType.of); _join(e.columnNames, ','); } } @override void visitUpsertClause(UpsertClause e, void arg) { _join(e.entries, ''); } @override void visitUpsertClauseEntry(UpsertClauseEntry e, void arg) { _keyword(TokenType.on); _keyword(TokenType.conflict); if (e.onColumns != null) { symbol('(', spaceBefore: true); _join(e.onColumns!, ','); symbol(')', spaceAfter: true); _where(e.where); } _keyword(TokenType.$do); visit(e.action, arg); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { _keyword(TokenType.$values); _join(e.values, ','); } @override void visitValuesSource(ValuesSource e, void arg) { _keyword(TokenType.$values); _join(e.values, ','); } @override void visitWhen(WhenComponent e, void arg) { _keyword(TokenType.when); visit(e.when, arg); _keyword(TokenType.then); visit(e.then, arg); } @override void visitWindowDefinition(WindowDefinition e, void arg) { symbol('(', spaceBefore: true); if (e.baseWindowName != null) { identifier(e.baseWindowName!); } if (e.partitionBy.isNotEmpty) { _keyword(TokenType.partition); _keyword(TokenType.by); _join(e.partitionBy, ','); } visitNullable(e.orderBy, arg); visitNullable(e.frameSpec, arg); symbol(')', spaceAfter: true); } @override void visitWithClause(WithClause e, void arg) { _keyword(TokenType.$with); if (e.recursive) { _keyword(TokenType.recursive); } _join(e.ctes, ','); } void _conflictClause(ConflictClause? clause) { if (clause != null) { _keyword(TokenType.on); _keyword(TokenType.conflict); _keyword(const { ConflictClause.rollback: TokenType.rollback, ConflictClause.abort: TokenType.abort, ConflictClause.fail: TokenType.fail, ConflictClause.ignore: TokenType.ignore, ConflictClause.replace: TokenType.replace, }[clause]!); } } void _from(Queryable? from) { if (from != null) { _keyword(TokenType.from); visit(from, null); } } /// Writes an identifier, escaping it if necessary. void identifier(String identifier, {bool spaceBefore = true, bool spaceAfter = true}) { if (isKeywordLexeme(identifier) || _notAKeywordRegex.hasMatch(identifier)) { identifier = '"$identifier"'; } symbol(identifier, spaceBefore: spaceBefore, spaceAfter: spaceAfter); } void _ifNotExists(bool ifNotExists) { if (ifNotExists) { _keyword(TokenType.$if); _keyword(TokenType.not); _keyword(TokenType.exists); } } void _join(Iterable nodes, String separatingSymbol) { var isFirst = true; for (final node in nodes) { if (!isFirst) { symbol(separatingSymbol, spaceAfter: true); } visit(node, null); isFirst = false; } } void _keyword(TokenType type) { symbol(reverseKeywords[type]!, spaceAfter: true, spaceBefore: true); } void _orderingMode(OrderingMode? mode) { if (mode != null) { _keyword(const { OrderingMode.ascending: TokenType.asc, OrderingMode.descending: TokenType.desc, }[mode]!); } } void _space() => buffer.writeCharCode($space); void _stringLiteral(String content) { final escapedChars = content.replaceAll("'", "''"); symbol("'$escapedChars'", spaceBefore: true, spaceAfter: true); } /// Writes the [lexeme], unchanged. void symbol(String lexeme, {bool spaceBefore = false, bool spaceAfter = false}) { if (needsSpace && spaceBefore) { _space(); } buffer.write(lexeme); needsSpace = spaceAfter; } void _where(Expression? where) { if (where != null) { _keyword(TokenType.where); visit(where, null); } } } /// Defines the [toSql] extension method that turns ast nodes into a compatible /// textual representation. /// /// Parsing the output of [toSql] will result in an equal AST. extension NodeToText on AstNode { /// Obtains a textual representation for AST nodes. /// /// Parsing the output of [toSql] will result in an equal AST. Since only the /// AST is used, the output will not contain comments. It's possible for the /// output to have more than just whitespace changes if there are multiple /// ways to represent an equivalent node (e.g. the no-op `FOR EACH ROW` on /// triggers). String toSql() { final builder = NodeSqlBuilder(null); builder.visit(this, null); return builder.buffer.toString(); } } // Allow 0, 1, 2, 3 in https://github.com/sqlite/sqlite/blob/665b6b6b35f10a46bb72377ade7c2e5d8ea42cb3/src/tokenize.c#L62-L80 final _notAKeywordRegex = RegExp('[^A-Za-z_0-9]'); lib/utils/find_referenced_tables.dart 644 0 0 10724 14071571527 16135 0ustar0 pubpublibrary utils.find_referenced_tables; import 'package:sqlparser/sqlparser.dart'; /// An AST-visitor that walks sql statements and finds all tables referenced in /// them. class ReferencedTablesVisitor extends RecursiveVisitor { /// All tables that have been referenced anywhere in this query. final Set foundTables = {}; final Set foundViews = {}; void _add(NamedResultSet? resultSet) { if (resultSet is Table) { foundTables.add(resultSet); } else if (resultSet is View) { foundViews.add(resultSet); } } @override void visitReference(Reference e, void arg) { var column = e.resolved; while (column is DelegatedColumn) { column = column.innerColumn; } if (column is TableColumn) { _add(column.table); } else if (column is ViewColumn) { _add(column.view); } visitChildren(e, arg); } NamedResultSet? _toResultSetOrNull(ResolvesToResultSet? resultSet) { final resolved = resultSet?.resultSet?.unalias(); return resolved is NamedResultSet ? resolved : null; } @override void visitTableReference(TableReference e, void arg) { final resolved = _toResultSetOrNull(e.resultSet); if (resolved != null) { _add(resolved); } visitChildren(e, arg); } } enum UpdateKind { insert, update, delete } /// A write to a table as found while analyzing a statement. class TableWrite { /// The table that a statement might write to when run. final Table table; /// What kind of update was found (e.g. insert, update or delete). final UpdateKind kind; TableWrite(this.table, this.kind); @override int get hashCode => 37 * table.hashCode + kind.hashCode; @override bool operator ==(dynamic other) { return other is TableWrite && other.table == table && other.kind == kind; } } /// Finds all tables that could be affected when executing a query. In /// contrast to [ReferencedTablesVisitor], which finds all references, this /// visitor only collects tables a query writes to. class UpdatedTablesVisitor extends ReferencedTablesVisitor { /// All tables that can potentially be updated by this query. /// /// Note that this is a subset of [foundTables], since an updating tables /// could reference tables it's not updating (e.g. with `INSERT INTO foo /// SELECT * FROM bar`). final Set writtenTables = {}; void _addIfResolved(ResolvesToResultSet? r, UpdateKind kind) { final resolved = _toResultSetOrNull(r); if (resolved != null && resolved is Table) { writtenTables.add(TableWrite(resolved, kind)); } } @override void visitDeleteStatement(DeleteStatement e, void arg) { _addIfResolved(e.from, UpdateKind.delete); visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { _addIfResolved(e.table, UpdateKind.update); visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { _addIfResolved(e.table, UpdateKind.insert); visitChildren(e, arg); } } /// Finds all writes to a table that occur anywhere inside the [root] node or a /// descendant. /// /// The [root] node must have all its references resolved. This means that using /// a node obtained via [SqlEngine.parse] directly won't report meaningful /// results. Instead, use [SqlEngine.analyze] or [SqlEngine.analyzeParsed]. /// /// If you want to find all referenced tables, use [findReferencedTables]. If /// you want to find writes (including their [UpdateKind]) and referenced /// tables, constrct a [UpdatedTablesVisitor] manually. /// Then, let it visit the [root] node. You can now use /// [UpdatedTablesVisitor.writtenTables] and /// [ReferencedTablesVisitor.foundTables]. This will only walk the ast once, /// whereas calling this and [findReferencedTables] will require two walks. /// Set findWrittenTables(AstNode root) { return (UpdatedTablesVisitor()..visit(root, null)).writtenTables; } /// Finds all tables referenced in [root] or a descendant. /// /// The [root] node must have all its references resolved. This means that using /// a node obtained via [SqlEngine.parse] directly won't report meaningful /// results. Instead, use [SqlEngine.analyze] or [SqlEngine.analyzeParsed]. /// /// If you want to use both [findWrittenTables] and this on the same ast node, /// follow the advice on [findWrittenTables] to only walk the ast once. Set
findReferencedTables(AstNode root) { return (ReferencedTablesVisitor()..visit(root, null)).foundTables; } lib/src/analysis/types/types.dart 644 0 0 3650 14155120333 15227 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; part 'expectation.dart'; part 'graph/relationships.dart'; part 'graph/type_graph.dart'; part 'resolving_visitor.dart'; /// Contains all information associated to a single type inference pass. class TypeInferenceSession { final TypeGraph graph = TypeGraph(); final EngineOptions options; final AnalysisContext context; TypeInferenceResults? results; TypeInferenceSession(this.context, [EngineOptions? options]) : options = options ?? EngineOptions() { results = TypeInferenceResults._(this); } void _markTypeResolved(Typeable t, ResolvedType r) { graph[t] = r; } void _checkAndResolve( Typeable t, ResolvedType r, TypeExpectation expectation) { _expectIsPossible(r, expectation); _markTypeResolved(t, r); } /// Returns the inferred type of [t], or `null` if it couldn't be inferred. ResolvedType? typeOf(Typeable? t) { return graph[t]; } void _addRelation(TypeRelation relationship) { graph.addRelation(relationship); } /// Check that [r] is compatible with [expectation]. /// /// This is not currently implemented. void _expectIsPossible(ResolvedType r, TypeExpectation expectation) {} /// This is not currently implemented. void _hintNullability(Typeable t, bool nullable) { graph.markNullability(t, nullable); } /// Asks the underlying [TypeGraph] to propagate known types via known /// [TypeRelation]s. /// /// The [SqlEngine] will call this method when analyzing a statement. There's /// no need to call it from user code. void _finish() { graph.performResolve(); } } /// Apis to view results of a type inference session. class TypeInferenceResults { final TypeInferenceSession session; TypeInferenceResults._(this.session); /// Finds the resolved type of [t], or `null` if the type of [t] could not /// be inferred. ResolvedType? typeOf(Typeable t) { return session.typeOf(t); } } lib/src/analysis/types/data.dart 644 0 0 11421 14207701772 15021 0ustar0 pubpubimport 'package:sqlparser/src/engine/sql_engine.dart'; /// Something that has a type. abstract class Typeable {} /// A type that sql expressions can have at runtime. enum BasicType { nullType, int, real, text, blob, } class ResolvedType { final BasicType? type; /// We set hints for additional information that might be useful for /// applications but aren't covered by just exposing a [BasicType]. See the /// comment on [TypeHint] for examples. final TypeHint? hint; /// Whether this type is nullable. A `null` value for [nullable] indicates /// that nullability is unknown. final bool? nullable; /// Whether this type is an array. final bool isArray; const ResolvedType( {this.type, this.hint, this.nullable = false, this.isArray = false}); const ResolvedType.bool({bool? nullable = false}) : this(type: BasicType.int, hint: const IsBoolean(), nullable: nullable); ResolvedType get withoutNullabilityInfo { return nullable == null ? this : ResolvedType( type: type, hint: hint, isArray: isArray, nullable: null); } ResolvedType withNullable(bool nullable) { return nullable == this.nullable ? this : copyWith(nullable: nullable); } ResolvedType toArray(bool? array) { return copyWith(isArray: array); } ResolvedType copyWith({TypeHint? hint, bool? nullable, bool? isArray}) { return ResolvedType( type: type, hint: hint ?? this.hint, nullable: nullable ?? this.nullable, isArray: isArray ?? this.isArray, ); } @override bool operator ==(dynamic other) { return identical(this, other) || other is ResolvedType && other.type == type && other.hint == hint && other.nullable == nullable && other.isArray == isArray; } @override int get hashCode { return type.hashCode + hint.hashCode + nullable.hashCode; } @override String toString() { return 'ResolvedType($type, hint: $hint, nullable: $nullable, ' 'array: $isArray)'; } } /// Provides more precise hints than the [BasicType]. For instance, booleans are /// stored as ints in sqlite, but it might be desirable to know whether an /// expression will actually be a boolean, so we could set the /// [ResolvedType.hint] to [IsBoolean]. abstract class TypeHint { const TypeHint(); @override int get hashCode => runtimeType.hashCode; @override bool operator ==(dynamic other) => other.runtimeType == runtimeType; } /// Type hint to mark that this type will contain a boolean value. class IsBoolean extends TypeHint { const IsBoolean(); } /// Type hint to mark that this type will contain a date time value. class IsDateTime extends TypeHint { const IsDateTime(); } /// Result of resolving a type. This can either have the resolved [type] set, /// or it can inform the called that it [needsContext] to resolve the type /// properly. Failure to resolve the type will have the [unknown] flag set. /// /// When you see a [ResolveResult] that is unknown or needs context in the /// final AST returned by [SqlEngine.analyze], assume that the type cannot be /// determined. class ResolveResult { /// The resolved type. final ResolvedType? type; /// Whether more context is needed to resolve the type. Used internally by the /// analyzer. final bool needsContext; /// Whether type resolution failed. final bool unknown; const ResolveResult(this.type) : needsContext = false, unknown = false; const ResolveResult.needsContext() : type = null, needsContext = true, unknown = false; const ResolveResult.unknown() : type = null, needsContext = false, unknown = true; bool get nullable => type?.nullable ?? true; ResolveResult mapResult(ResolvedType Function(ResolvedType?) map) { if (type != null) { return ResolveResult(map(type)); } else if (needsContext) { return const ResolveResult.needsContext(); } else { return const ResolveResult.unknown(); } } /// Copies the result with the [nullable] information, if there is one. If /// there isn't, the failure state will be copied into the new /// [ResolveResult]. ResolveResult withNullable(bool nullable) { return mapResult((r) => r!.withNullable(nullable)); } @override bool operator ==(dynamic other) { return identical(this, other) || other is ResolveResult && other.type == type && other.needsContext == needsContext && other.unknown == unknown; } @override int get hashCode => type.hashCode + needsContext.hashCode + unknown.hashCode; @override String toString() { if (type != null) { return 'ResolveResult: $type'; } else { return 'ResolveResult(needsContext: $needsContext, unknown: $unknown)'; } } } lib/src/analysis/types/resolving_visitor.dart 644 0 0 56151 14207702737 17712 0ustar0 pubpubpart of 'types.dart'; const _intType = ResolvedType(type: BasicType.int); const _realType = ResolvedType(type: BasicType.real); const _textType = ResolvedType(type: BasicType.text); const _expectInt = ExactTypeExpectation.laxly(_intType); const _expectNum = RoughTypeExpectation.numeric(); const _expectString = ExactTypeExpectation.laxly(_textType); class TypeResolver extends RecursiveVisitor { final TypeInferenceSession session; final Set _handledColumns = {}; TypeResolver(this.session); void run(AstNode root) { visit(root, const NoTypeExpectation()); // annotate Columns as well. They implement Typeable, but aren't an ast // node, which means this visitor doesn't find them root.acceptWithoutArg(_ResultColumnVisitor(this)); session._finish(); } @override void visitSelectStatement(SelectStatement e, TypeExpectation arg) { _handleWhereClause(e); var currentColumnIndex = 0; final columnExpectations = arg is SelectTypeExpectation ? arg.columnExpectations : const []; for (final child in e.childNodes) { if (child == e.where) continue; // handled above if (child is ResultColumn) { if (child is ExpressionResultColumn) { final expectation = currentColumnIndex < columnExpectations.length ? columnExpectations[currentColumnIndex] : const NoTypeExpectation(); visit(child, expectation); currentColumnIndex++; } else if (child is StarResultColumn) { currentColumnIndex += child.scope.availableColumns.length; } else if (child is NestedQueryColumn) { visit(child.select, arg); } } else { visit(child, arg); } } } @override void visitSubQuery(SubQuery e, TypeExpectation arg) { final columnsOfQuery = e.select.resolvedColumns!; if (columnsOfQuery.isEmpty) { return super.visitSubQuery(e, arg); } // The query should return one column only, but this is not the right place // to lint that. Just pick any column and resolve to that. final columnForExpr = columnsOfQuery.first; session._addRelation(CopyTypeFrom(e, columnForExpr)); visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, TypeExpectation arg) { if (e.withClause != null) visit(e.withClause!, arg); visitList(e.targetColumns, const NoTypeExpectation()); final targets = e.resolvedTargetColumns ?? const []; for (final column in targets) { _handleColumn(column, e); } final expectations = targets.map((r) { if (session.graph.knowsType(r)) { return ExactTypeExpectation(session.typeOf(r)!); } return const NoTypeExpectation(); }).toList(); visit(e.source, SelectTypeExpectation(expectations)); visitNullable(e.upsert, const NoTypeExpectation()); visitNullable(e.returning, const NoTypeExpectation()); } @override void visitCrudStatement(CrudStatement stmt, TypeExpectation arg) { if (stmt is StatementWithWhere) { final typedStmt = stmt as StatementWithWhere; _handleWhereClause(typedStmt); visitExcept(stmt, typedStmt.where, arg); } else { visitChildren(stmt, arg); } } @override void visitCreateIndexStatement(CreateIndexStatement e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } @override void visitJoin(Join e, TypeExpectation arg) { final constraint = e.constraint; if (constraint is OnConstraint) { // ON , should be boolean visit(constraint.expression, const ExactTypeExpectation.laxly(ResolvedType.bool())); visitExcept(e, constraint.expression, arg); } else { visitChildren(e, arg); } } @override void visitSetComponent(SetComponent e, TypeExpectation arg) { visit(e.column, const NoTypeExpectation()); _lazyCopy(e.expression, e.column); visit(e.expression, const NoTypeExpectation()); } @override void visitLimit(Limit e, TypeExpectation arg) { visit(e.count, _expectInt); visitNullable(e.offset, _expectInt); } @override void visitFrameSpec(FrameSpec e, TypeExpectation arg) { // handle something like "RANGE BETWEEN ? PRECEDING AND ? FOLLOWING if (e.start.isExpressionOffset) { visit(e.start.offset!, _expectInt); } if (e.end.isExpressionOffset) { visit(e.end.offset!, _expectInt); } } @override void defaultLiteral(Literal e, TypeExpectation arg) { late ResolvedType type; var nullable = false; if (e is NullLiteral) { type = const ResolvedType(type: BasicType.nullType, nullable: true); nullable = true; } else if (e is StringLiteral) { type = e.isBinary ? const ResolvedType(type: BasicType.blob) : _textType; } else if (e is BooleanLiteral) { type = const ResolvedType.bool(); } else if (e is NumericLiteral) { type = e.isInt ? _intType : _realType; } else if (e is TimeConstantLiteral) { type = _textType; } session._hintNullability(e, nullable); session._checkAndResolve(e, type, arg); } @override void visitVariable(Variable e, TypeExpectation arg) { _inferAsVariable(e, arg); } @override void visitDriftSpecificNode(DriftSpecificNode e, TypeExpectation arg) { if (e is DartExpressionPlaceholder) { _inferAsVariable(e, arg); } else { super.visitDriftSpecificNode(e, arg); } } void _inferAsVariable(Expression e, TypeExpectation arg) { ResolvedType? resolved; if (e is Variable) { resolved = session.context.stmtOptions.specifiedTypeOf(e); } resolved ??= _inferFromContext(arg); if (resolved != null) { session._checkAndResolve(e, resolved, arg); } else if (arg is RoughTypeExpectation) { session._addRelation(DefaultType(e, defaultType: arg.defaultType())); } visitChildren(e, arg); } @override void visitCollateExpression(CollateExpression e, TypeExpectation arg) { session._checkAndResolve(e, _textType, arg); visit(e.inner, _expectString); } @override void visitExists(ExistsExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); visit(e.select, const NoTypeExpectation()); } @override void visitUnaryExpression(UnaryExpression e, TypeExpectation arg) { final operatorType = e.operator.type; if (operatorType == TokenType.plus) { // plus is a no-op, so copy type from child session._addRelation(CopyTypeFrom(e, e.inner)); visit(e.inner, arg); } else if (operatorType == TokenType.not) { // unary not expression - boolean, but nullability depends on child node. session._checkAndResolve(e, const ResolvedType.bool(nullable: null), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.inner])); visit(e.inner, const ExactTypeExpectation.laxly(ResolvedType.bool())); } else if (operatorType == TokenType.minus) { // unary minus - can be int or real depending on child node session._addRelation(CopyAndCast(e, e.inner, CastMode.numeric)); visit(e.inner, const RoughTypeExpectation.numeric()); } else if (operatorType == TokenType.tilde) { // bitwise negation - definitely int, but nullability depends on child session._checkAndResolve( e, const ResolvedType(type: BasicType.int, nullable: null), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.inner])); visit(e.inner, const NoTypeExpectation()); } else { throw StateError( 'Unary operator $operatorType not recognized by types2. At $e'); } } @override void visitTuple(Tuple e, TypeExpectation arg) { if (arg is SelectTypeExpectation) { // We have a specific type requirement for each entry, let's use that final expectations = arg.columnExpectations; for (var i = 0; i < e.expressions.length; i++) { final expectation = i < expectations.length ? expectations[i] : const NoTypeExpectation(); visit(e.expressions[i], expectation); } } else { // Assume that this tuple forms an array, and clear the array expectation // for children. final expectationForChildren = arg.clearArray(); visitChildren(e, expectationForChildren); // make children non-arrays for (final child in e.childNodes) { session._addRelation(CopyTypeFrom(child, e, array: false)); } } } @override void visitBetweenExpression(BetweenExpression e, TypeExpectation arg) { visitChildren(e, _expectNum); session .._checkAndResolve(e, const ResolvedType.bool(), arg) .._addRelation(NullableIfSomeOtherIs(e, e.childNodes)) .._addRelation(HaveSameType(e.lower, e.upper)) .._addRelation(HaveSameType(e.check, e.lower)); } @override void visitBinaryExpression(BinaryExpression e, TypeExpectation arg) { switch (e.operator.type) { case TokenType.and: case TokenType.or: session._checkAndResolve(e, const ResolvedType.bool(), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); // logic expressions, so children must be boolean visitChildren(e, const ExactTypeExpectation.laxly(ResolvedType.bool())); break; case TokenType.equal: case TokenType.doubleEqual: case TokenType.exclamationEqual: case TokenType.lessMore: case TokenType.less: case TokenType.lessEqual: case TokenType.more: case TokenType.moreEqual: // comparison. Returns bool, copying nullability from children. session._checkAndResolve(e, const ResolvedType.bool(), arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); // Not technically a requirement, but assume lhs and rhs have the same // type. session._addRelation(HaveSameType(e.left, e.right)); visitChildren(e, const NoTypeExpectation()); break; case TokenType.plus: case TokenType.minus: case TokenType.star: case TokenType.slash: session._addRelation( CopyEncapsulating(e, [e.left, e.right], CastMode.numericPreferInt)); visitChildren(e, const RoughTypeExpectation.numeric()); break; // all of those only really make sense for integers case TokenType.shiftLeft: case TokenType.shiftRight: case TokenType.pipe: case TokenType.ampersand: case TokenType.percent: const type = ResolvedType(type: BasicType.int); session._checkAndResolve(e, type, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); visitChildren(e, const ExactTypeExpectation.laxly(type)); break; case TokenType.doublePipe: // string concatenation. session._checkAndResolve(e, _textType.withoutNullabilityInfo, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.left, e.right])); const childExpectation = ExactTypeExpectation.laxly(_textType); visit(e.left, childExpectation); visit(e.right, childExpectation); break; case TokenType.dashRangle: // Extract as JSON, this takes two strings and returns a string (or // `NULL` if the value wasn't found). session._checkAndResolve(e, _textType.withNullable(true), arg); visit(e.left, _expectString); visit(e.right, _expectString); break; case TokenType.dashRangleRangle: // Extract as JSON to SQL value. session._hintNullability(e, true); visit(e.left, _expectString); visit(e.right, _expectString); break; default: throw StateError('Binary operator ${e.operator.type} not recognized ' 'by types2. At $e'); } } @override void visitIsExpression(IsExpression e, TypeExpectation arg) { session .._checkAndResolve(e, const ResolvedType.bool(), arg) .._addRelation(HaveSameType(e.left, e.right)) .._hintNullability(e, false); visitChildren(e, const NoTypeExpectation()); } @override void visitIsNullExpression(IsNullExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); session._hintNullability(e, false); visitChildren(e, const NoTypeExpectation()); } @override void visitInExpression(InExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType.bool(), arg); session._addRelation(NullableIfSomeOtherIs(e, e.childNodes)); session._addRelation(CopyTypeFrom(e.inside, e.left, array: true)); visitChildren(e, const NoTypeExpectation()); } @override void visitCaseExpression(CaseExpression e, TypeExpectation arg) { session._addRelation(CopyEncapsulating(e, [ for (final when in e.whens) when.then, if (e.elseExpr != null) e.elseExpr, ])); if (e.base != null) { session._addRelation( CopyEncapsulating(e.base, [for (final when in e.whens) when.when]), ); } visitNullable(e.base, const NoTypeExpectation()); visitExcept(e, e.base, arg); } @override void visitWhen(WhenComponent e, TypeExpectation arg) { final parent = e.parent; if (parent is CaseExpression && parent.base != null) { // case expressions with base -> condition is compared to base session._addRelation(CopyTypeFrom(e.when, parent.base)); visit(e.when, const NoTypeExpectation()); } else { // case expression without base -> the conditions are booleans visit(e.when, const ExactTypeExpectation(ResolvedType.bool())); } visit(e.then, arg); } @override void visitCastExpression(CastExpression e, TypeExpectation arg) { final type = session.context.schemaSupport.resolveColumnType(e.typeName); session._checkAndResolve(e, type, arg); session._addRelation(NullableIfSomeOtherIs(e, [e.operand])); visit(e.operand, const NoTypeExpectation()); } @override void visitStringComparison( StringComparisonExpression e, TypeExpectation arg) { session._checkAndResolve(e, const ResolvedType(type: BasicType.text), arg); session._addRelation(NullableIfSomeOtherIs( e, [ e.left, e.right, if (e.escape != null) e.escape, ], )); visit(e.left, _expectString); visit(e.right, _expectString); visitNullable(e.escape, _expectString); } @override void visitParentheses(Parentheses e, TypeExpectation arg) { session._addRelation(CopyTypeFrom(e, e.expression)); visit(e.expression, arg); } @override void visitReference(Reference e, TypeExpectation arg) { final resolved = e.resolvedColumn; if (resolved == null) return; _handleColumn(resolved, e); _lazyCopy(e, resolved); } @override void visitExpressionInvocation(ExpressionInvocation e, TypeExpectation arg) { final type = _resolveInvocation(e); if (type != null) { session._checkAndResolve(e, type, arg); } final visited = _resolveFunctionArguments(e); for (final child in e.childNodes) { if (!visited.contains(child)) { visit(child, const NoTypeExpectation()); } } } FunctionHandler? _functionHandlerFor(ExpressionInvocation e) { return session.options.addedFunctions[e.name.toLowerCase()]; } ResolvedType? _resolveInvocation(ExpressionInvocation e) { final params = e.expandParameters(); void nullableIfChildIs() { session._addRelation(NullableIfSomeOtherIs(e, params)); } final lowercaseName = e.name.toLowerCase(); switch (lowercaseName) { case 'round': nullableIfChildIs(); //if there is only one params, it rounds to int. Otherwise real if (params.length == 1) { return _intType; } else { return _realType; } // ignore: dead_code throw AssertionError(); // required so that this switch compiles case 'sum': session._addRelation(CopyAndCast(e, params.first, CastMode.numeric)); session._addRelation(DefaultType(e, defaultType: _realType)); nullableIfChildIs(); return null; case 'lower': case 'ltrim': case 'printf': case 'format': case 'replace': case 'rtrim': case 'substr': case 'trim': case 'upper': nullableIfChildIs(); return _textType.withoutNullabilityInfo; case 'group_concat': return _textType.withNullable(true); case 'date': case 'time': case 'datetime': case 'julianday': case 'strftime': case 'unixepoch': case 'char': case 'hex': case 'quote': case 'soundex': case 'sqlite_compileoption_set': case 'sqlite_version': case 'typeof': return _textType; case 'changes': case 'last_insert_rowid': case 'random': case 'sqlite_compileoption_used': case 'total_changes': case 'count': case 'row_number': case 'rank': case 'dense_rank': case 'ntile': return _intType; case 'instr': case 'length': case 'unicode': nullableIfChildIs(); return _intType; case 'randomblob': case 'zeroblob': return const ResolvedType(type: BasicType.blob); case 'total': case 'avg': case 'percent_rank': case 'cume_dist': return _realType; case 'abs': case 'likelihood': case 'likely': case 'unlikely': session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'coalesce': case 'ifnull': session._addRelation(CopyEncapsulating( e, params, null, EncapsulatingNullability.nullIfAll)); for (final param in params) { session._addRelation(DefaultType(param, isNullable: true)); } return null; case 'nullif': session._hintNullability(e, true); session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'first_value': case 'last_value': case 'lag': case 'lead': case 'nth_value': session._addRelation(CopyTypeFrom(e, params.first)); return null; case 'max': case 'min': session._hintNullability(e, true); session._addRelation(CopyEncapsulating(e, params)); return null; } final extensionHandler = _functionHandlerFor(e); if (extensionHandler != null) { return extensionHandler.inferReturnType(session.context, e, params).type; } session.context.reportError(AnalysisError( type: AnalysisErrorType.unknownFunction, message: 'Function ${e.name} could not be found', relevantNode: e, )); return null; } Set _resolveFunctionArguments(SqlInvocation e) { final params = e.expandParameters(); final visited = {}; final name = e.name.toLowerCase(); if (name == 'nth_value' && params.length >= 2 && params[1] is Expression) { // the second argument of nth_value is always an integer final secondParam = params[1] as Expression; visit(secondParam, _expectInt); visited.add(secondParam); } final extensionHandler = e is ExpressionInvocation ? _functionHandlerFor(e) : null; if (extensionHandler != null) { for (final arg in params) { if (arg is! Expression) continue; final expressionArgument = arg; final result = extensionHandler.inferArgumentType( session.context, e, expressionArgument); final type = result.type; if (type != null) { session._markTypeResolved(expressionArgument, type); } visited.add(expressionArgument); } } return visited; } @override void visitUpsertClauseEntry(UpsertClauseEntry e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } @override void visitDoUpdate(DoUpdate e, TypeExpectation arg) { _handleWhereClause(e); visitExcept(e, e.where, arg); } void _handleColumn(Column? column, [AstNode? context]) { if (session.graph.knowsType(column) || _handledColumns.contains(column)) { return; } _handledColumns.add(column); if (column is ColumnWithType) { session._markTypeResolved(column, column.type!); } else if (column is ExpressionColumn) { _lazyCopy(column, column.expression); } else if (column is CompoundSelectColumn) { session._addRelation(CopyEncapsulating(column, column.columns)); column.columns.forEach(_handleColumn); } else if (column is ValuesSelectColumn) { session._addRelation(CopyEncapsulating(column, column.expressions)); } else if (column is DelegatedColumn && column.innerColumn != null) { _handleColumn(column.innerColumn); if (column is AvailableColumn) { // The nullability depends on whether the column was introduced in an // outer join. final model = context != null ? JoinModel.of(context) : null; final isNullable = model == null || model.availableColumnIsNullable(column); _lazyCopy(column, column.innerColumn, makeNullable: isNullable); } else { _lazyCopy(column, column.innerColumn); } } } void _lazyCopy(Typeable to, Typeable? from, {bool makeNullable = false}) { if (session.graph.knowsType(from)) { var type = session.typeOf(from)!; if (makeNullable) { type = type.withNullable(true); session._markTypeResolved(to, type); } else if (session.graph.knowsNullability(from)) { session._markTypeResolved(to, type); } else { session._markTypeResolved(to, type); session._addRelation(NullableIfSomeOtherIs(to, [from!])); } } else { session._addRelation(CopyTypeFrom(to, from, makeNullable: makeNullable)); } } void _handleWhereClause(HasWhereClause e) { if (e.where != null) { // assume that a where statement is a boolean expression. Sqlite // internally casts (https://www.sqlite.org/lang_expr.html#booleanexpr), // so be lax visit(e.where!, const ExactTypeExpectation.laxly(ResolvedType.bool())); } } ResolvedType? _inferFromContext(TypeExpectation expectation) { if (expectation is ExactTypeExpectation) { return expectation.type; } return null; } } class _ResultColumnVisitor extends RecursiveVisitor { final TypeResolver resolver; _ResultColumnVisitor(this.resolver); @override void visitBaseSelectStatement(BaseSelectStatement stmt, void arg) { if (stmt.resolvedColumns != null) { for (final column in stmt.resolvedColumns!) { resolver._handleColumn(column, stmt); } } visitChildren(stmt, arg); } void _handleReturning(StatementReturningColumns stmt) { final columns = stmt.returnedResultSet?.resolvedColumns; if (columns != null) { for (final column in columns) { resolver._handleColumn(column, stmt); } } } @override void visitInsertStatement(InsertStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } @override void visitDeleteStatement(DeleteStatement e, void arg) { _handleReturning(e); visitChildren(e, arg); } } lib/src/analysis/types/expectation.dart 644 0 0 5231 14000111271 16371 0ustar0 pubpubpart of 'types.dart'; /// Contains expectations on the type that a [Typeable] might have. /// /// Different instances of this class are passed along when descending into the /// AST during type analysis. For instance, logical binary expressions might /// expect that their operands are logical expressions as well. This model /// also allows us to construct more complicated relationships. For instance, /// we can express the expected column types for a `INSERT INTO SELECT` /// statement. abstract class TypeExpectation { const TypeExpectation(); } /// Passed along when an ast node makes no assumption on the type of its /// child nodes. class NoTypeExpectation extends TypeExpectation { const NoTypeExpectation(); } /// Passed down when a node must have a known type. class ExactTypeExpectation extends TypeExpectation { /// The type we expect the child nodes to have. final ResolvedType type; /// Whether the child node max have another type than [type]. /// /// When false, we can report a compile-time error for a type mismatch. final bool lax; const ExactTypeExpectation._(this.type, this.lax); const ExactTypeExpectation(this.type) : lax = false; const ExactTypeExpectation.laxly(this.type) : lax = true; } /// Passed down when the general type must match (e.g. "numeric), but the /// exact type is unknown. /// /// This makes no expectation on nullability. class RoughTypeExpectation extends TypeExpectation { final _RoughType _type; const RoughTypeExpectation._(this._type); const RoughTypeExpectation.numeric() : this._(_RoughType.numeric); bool accepts(ResolvedType type) { final baseType = type.type; switch (_type) { case _RoughType.numeric: return baseType == BasicType.int || baseType == BasicType.real; } } ResolvedType defaultType() { switch (_type) { case _RoughType.numeric: return const ResolvedType(type: BasicType.real); } } } enum _RoughType { numeric, } /// Type expectation for result columns in a select statement. /// /// This can be used to set expectations in an `INSERT INTO SELECT` statement, /// where the column types are constrained by what's expected in the insert /// statement. class SelectTypeExpectation extends TypeExpectation { final List columnExpectations; SelectTypeExpectation(this.columnExpectations); } extension on TypeExpectation { TypeExpectation clearArray() { if (this is ExactTypeExpectation) { final expectation = this as ExactTypeExpectation; if (expectation.type.isArray) { return ExactTypeExpectation._( expectation.type.toArray(false), expectation.lax); } } return this; } } lib/src/analysis/types/graph/type_graph.dart 644 0 0 21225 14207702555 17356 0ustar0 pubpubpart of '../types.dart'; class TypeGraph { final _ResolvedVariables variables = _ResolvedVariables(); final Map _knownTypes = {}; final Map _knownNullability = {}; final List _relations = []; final Map> _edges = {}; final Set _candidateForLaxMultiPropagation = {}; final List _defaultTypes = []; ResolvedType? operator [](Typeable? t) { final normalized = variables.normalize(t); if (_knownTypes.containsKey(normalized)) { final type = _knownTypes[normalized]; final nullability = _knownNullability[normalized]; if (nullability != null) { return type!.withNullable(nullability); } return type; } return null; } void operator []=(Typeable? t, ResolvedType type) { final normalized = variables.normalize(t); _knownTypes[normalized] = type; if (type.nullable != null && !_knownNullability.containsKey(normalized)) { // nullability is known _knownNullability[normalized] = type.nullable; } } bool knowsType(Typeable? t) => _knownTypes.containsKey(variables.normalize(t)); bool knowsNullability(Typeable? t) { final normalized = variables.normalize(t); final knownType = _knownTypes[normalized]; return (knownType != null && knownType.nullable != null) || _knownNullability.containsKey(normalized); } void addRelation(TypeRelation relation) { _relations.add(relation); } void markNullability(Typeable t, bool isNullable) { _knownNullability[variables.normalize(t)] = isNullable; } void performResolve() { _indexRelations(); var queue = List.of(_knownTypes.keys); while (queue.isNotEmpty) { _propagateTypeInfo(queue, queue.removeLast()); } // propagate many-to-one sources where we don't know each source type, but // some of them. queue = List.of(_candidateForLaxMultiPropagation); while (queue.isNotEmpty) { _propagateTypeInfo(queue, queue.removeLast(), laxMultiSourcePropagation: true); } // apply default types for (final applyDefault in _defaultTypes) { final target = applyDefault.target; final type = applyDefault.defaultType; if (type != null && !knowsType(target)) { this[target] = applyDefault.defaultType!; } final nullability = applyDefault.isNullable; if (nullability != null && _knownNullability.containsKey(target)) { markNullability(target, nullability); } } } void _propagateTypeInfo(List resolved, Typeable? t, {bool laxMultiSourcePropagation = false}) { if (!_edges.containsKey(t)) return; // propagate changes for (final edge in _edges[t]!) { if (edge is CopyTypeFrom) { var type = this[edge.other]; if (edge.array != null) { type = type!.toArray(edge.array); } if (edge.makeNullable) { _knownNullability[edge.target] = true; } _copyType(resolved, edge.other, edge.target, type); } else if (edge is HaveSameType) { _copyType(resolved, t, edge.getOther(t)); } else if (edge is CopyAndCast) { _copyType(resolved, t, edge.target, this[t]!.cast(edge.cast)); } else if (edge is MultiSourceRelation) { // handle many-to-one changes, if all targets have been resolved or // lax handling is enabled. if (laxMultiSourcePropagation || edge.from.every(knowsType)) { _propagateManyToOne(edge, resolved); _candidateForLaxMultiPropagation.removeAll(edge.from); } else { _candidateForLaxMultiPropagation.add(t); } } } } void _propagateManyToOne(MultiSourceRelation edge, List resolved) { if (edge is CopyEncapsulating) { if (!knowsType(edge.target)) { final fromTypes = edge.from.map((t) => this[t]).where((e) => e != null); var encapsulated = _encapsulate(fromTypes, edge.nullability); if (encapsulated != null) { if (edge.cast != null) { encapsulated = encapsulated.cast(edge.cast!); } this[edge.target] = encapsulated; resolved.add(edge.target); } } } else if (edge is NullableIfSomeOtherIs && !_knownNullability.containsKey(edge.target)) { final nullable = edge.from .map((e) => _knownNullability[e]) .any((nullable) => nullable == true); _knownNullability[edge.target] = nullable; } } void _copyType(List resolved, Typeable? from, Typeable to, [ResolvedType? type]) { // if the target hasn't been resolved yet, copy the current type and // visit the target later if (!knowsType(to)) { this[to] = type ?? this[from]!; resolved.add(to); } } ResolvedType? _encapsulate( Iterable targets, EncapsulatingNullability nullability) { return targets.fold(null, (previous, element) { if (previous == null) return element; final previousType = previous.type; final elementType = element!.type; bool nullableTogether; switch (nullability) { case EncapsulatingNullability.nullIfAny: nullableTogether = previous.nullable == true || element.nullable == true; break; case EncapsulatingNullability.nullIfAll: nullableTogether = previous.nullable == true && element.nullable == true; break; } if (previousType == elementType || elementType == BasicType.nullType) { return previous.withNullable(nullableTogether); } if (previousType == BasicType.nullType) { return element.withNullable(nullableTogether); } bool isIntOrNumeric(BasicType? type) { return type == BasicType.int || type == BasicType.real; } // encapsulate two different numeric types to real if (isIntOrNumeric(previousType) && isIntOrNumeric(elementType)) { return ResolvedType(type: BasicType.real, nullable: nullableTogether); } // fallback to text if everything else fails return const ResolvedType(type: BasicType.text); }); } void _indexRelations() { _edges.clear(); void put(Typeable? t, TypeRelation r) { _edges.putIfAbsent(t, () => []).add(r); } void putAll(MultiSourceRelation r) { for (final element in r.from) { put(element, r); } } for (final relation in _relations) { if (relation is NullableIfSomeOtherIs) { putAll(relation); } else if (relation is CopyTypeFrom) { put(relation.other, relation); } else if (relation is CopyEncapsulating) { putAll(relation); } else if (relation is HaveSameType) { put(relation.first, relation); put(relation.second, relation); } else if (relation is DefaultType) { _defaultTypes.add(relation); } else if (relation is CopyAndCast) { put(relation.other, relation); } else { throw AssertionError('Unknown type relation: $relation'); } } } } /// Describes how the type of different [Typeable] instances has an effect on /// others. /// /// Note that all logic is handled in the type graph, these are logic-less model /// classes only. abstract class TypeRelation {} /// Relation that only has an effect on one [Typeable] -- namely, [target]. abstract class DirectedRelation implements TypeRelation { /// The only [Typeable] effected by this relation. Typeable? get target; } /// Relation where the type of multiple [Typeable] instances must be known. abstract class MultiSourceRelation implements DirectedRelation { List get from; } /// Keeps track of resolved variable types so that they can be re-used. /// Different [Variable] instances can refer to the same logical sql variable, /// so we keep track of them. class _ResolvedVariables { final Map _referenceForIndex = {}; Typeable? normalize(Typeable? t) { if (t is! Variable) return t; final normalized = t; final index = normalized.resolvedIndex; if (index != null) { return _referenceForIndex[index] ??= normalized; } else { return null; } } } extension ResolvedTypeUtils on ResolvedType { ResolvedType cast(CastMode mode) { switch (mode) { case CastMode.numeric: case CastMode.numericPreferInt: if (type == BasicType.int || type == BasicType.real) return this; return mode == CastMode.numeric ? const ResolvedType(type: BasicType.real) : const ResolvedType(type: BasicType.int); case CastMode.boolean: return const ResolvedType.bool(); } } } lib/src/analysis/types/graph/relationships.dart 644 0 0 5140 14107761157 20060 0ustar0 pubpubpart of '../types.dart'; /// Dependency declaring that [target] is nullable if any in [from] is /// nullable. class NullableIfSomeOtherIs extends TypeRelation implements MultiSourceRelation { @override final Typeable target; @override final List from; NullableIfSomeOtherIs(this.target, this.from); } /// Dependency declaring that [target] has exactly the same type as [other]. class CopyTypeFrom extends TypeRelation implements DirectedRelation { @override final Typeable target; final Typeable? other; /// When true, [target] will be the array-variant of [other]. When false, /// [target] will be the scalar variant of [other]. When null, nothing will be /// transformed. final bool? array; /// Whether [target] is the nullable version of [other]. final bool makeNullable; CopyTypeFrom(this.target, this.other, {this.array, this.makeNullable = false}); } /// Dependency declaring that [target] has a type that matches all of [from]. class CopyEncapsulating extends TypeRelation implements MultiSourceRelation { @override final Typeable? target; @override final List from; final CastMode? cast; final EncapsulatingNullability nullability; CopyEncapsulating(this.target, this.from, [this.cast, this.nullability = EncapsulatingNullability.nullIfAny]); } /// Dependency declaring that [first] and [second] have the same type. This is /// an optional dependency that will only be applied when one type is known and /// the other is not. class HaveSameType extends TypeRelation { final Typeable first; final Typeable second; HaveSameType(this.first, this.second); Typeable getOther(Typeable? t) { assert(t == first || t == second); return t == first ? second : first; } } /// Dependency declaring that, if no better option is found, [target] should /// have the specified [defaultType]. class DefaultType extends TypeRelation implements DirectedRelation { @override final Typeable target; final ResolvedType? defaultType; final bool? isNullable; DefaultType(this.target, {this.defaultType, this.isNullable}); } enum CastMode { numeric, /// Like [numeric], but assume [BasicType.int] if the resulting type doesn't /// match. numericPreferInt, boolean, } enum EncapsulatingNullability { nullIfAny, nullIfAll, } /// Dependency declaring that [target] has the same type as [other] after /// casting it with [cast]. class CopyAndCast extends TypeRelation implements DirectedRelation { @override final Typeable target; final Typeable other; final CastMode cast; CopyAndCast(this.target, this.other, this.cast); } lib/src/analysis/types/join_analysis.dart 644 0 0 11333 14131303604 16740 0ustar0 pubpubimport '../../ast/ast.dart'; import '../analysis.dart'; /// Tracks table references that must be non-nullable in a query row. /// /// This is used to determine the nullability of column references. For /// instance, consider the following query: /// /// ```sql /// SELECT foo.x, bar.y FROM foo /// LEFT OUTER JOIN bar ON ... /// ``` /// /// Clearly, `foo.x` is non-nullable in the result if `x` is a non-nullable /// column in `foo`. We can't say the same thing about `bar.y` though: Even if /// the column is declared to be `NOT NULL`, `bar` might be nullable in this /// query. /// /// A [JoinModel] is attached to each basic [SelectStatement]. You can obtain /// the model for any ast node via [JoinModel.of]. It will lookup the model from /// the enclosing [SelectStatement], if there is one. /// /// If a [Reference] refers to a table that's in [JoinModel.nonNullable] and /// the resolved column is non-nullable, we can assume that the reference is /// going to be non-nullable too. /// /// At the moment, we consider the following tables to be /// [JoinModel.nonNullable]: /// - the "primary" table of a select statement (`foo` in the example above) /// - inner, cross, regular (no keyword, comma) joins /// /// In the future, we'll also consider foreign key constraints. class JoinModel { final List nonNullable; JoinModel._(this.nonNullable); factory JoinModel._resolve(AstNode statement) { final visitor = _FindNonNullableJoins(); statement.accept(visitor, true); return JoinModel._(visitor.nonNullable); } static JoinModel? of(AstNode node) { final enclosingStatement = node.enclosingOfType(); if (enclosingStatement == null) return null; final existing = enclosingStatement.meta(); if (existing != null) return existing; final created = JoinModel._resolve(enclosingStatement); enclosingStatement.setMeta(created); return created; } /// Computes whether the element the [reference] is pointing to is nullable /// from the perspective of this join model. /// /// This does not include the computed nullability of what the reference is /// referring to, just whether the reference points to a table that may not /// be present because it comes from an outer join. bool? referenceIsNullable(Reference reference) { final resolved = reference.resolvedColumn; if (resolved is AvailableColumn) { return availableColumnIsNullable(resolved); } final resultSet = reference.resultEntity; // ignore: avoid_returning_null if (resultSet == null) return null; return !nonNullable.contains(resultSet); } /// Returns whether an [AvailableColumn] is nullable from the perspective of /// this join model by checking whether it comes from an outer join. bool availableColumnIsNullable(AvailableColumn column) { return !nonNullable.contains(column.source); } /// Checks whether the result set is nullable in the surrounding select /// statement. bool isNullableTable(ResultSet resultSet) { return nonNullable.every((nonNullableRef) { return nonNullableRef.resultSet.resultSet != resultSet; }); } } // The boolean arg indicates whether a visited queryable is needed for the // result to have any rows (which, in particular, mean's its non-nullable) class _FindNonNullableJoins extends RecursiveVisitor { final List nonNullable = []; void _addIfMakesResultStatementAvailable(TableOrSubquery node) { final resultSet = node.availableResultSet; if (resultSet != null) nonNullable.add(resultSet); } @override void visitSelectStatement(SelectStatement e, bool arg) { visitNullable(e.from, true); } @override void visitDeleteStatement(DeleteStatement e, bool arg) { visit(e.table, true); } @override void visitInsertStatement(InsertStatement e, bool arg) { visit(e.table, true); } @override void visitUpdateStatement(UpdateStatement e, bool arg) { visit(e.table, true); visitNullable(e.from, true); } @override void visitJoinClause(JoinClause e, bool arg) { if (!arg) return; visit(e.primary, true); for (final additional in e.joins) { if (additional.operator != JoinOperator.left && additional.operator != JoinOperator.leftOuter) { visit(additional, true); } } } @override void visitTableReference(TableReference e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } @override void visitTableValuedFunction(TableValuedFunction e, bool arg) { if (arg) _addIfMakesResultStatementAvailable(e); } } lib/src/analysis/error.dart 644 0 0 4222 14205514430 14045 0ustar0 pubpubpart of 'analysis.dart'; class AnalysisError { final SyntacticEntity? source; final String? message; final AnalysisErrorType type; AnalysisError._internal(this.type, this.message, this.source); AnalysisError( {required this.type, this.message, SyntacticEntity? relevantNode}) : source = relevantNode; @Deprecated('Use source instead') AstNode? get relevantNode => source as AstNode?; factory AnalysisError.fromParser(ParsingError error) { return AnalysisError._internal( AnalysisErrorType.synctactic, error.message, error.token, ); } /// The relevant portion of the source code that caused this error. Some AST /// nodes don't have a span, in that case this error is going to have a null /// span as well. FileSpan? get span => source?.span; @override String toString() { final msgSpan = span; if (msgSpan != null) { return msgSpan.message(message ?? type.toString(), color: true); } else { return 'Error: $type: $message at $relevantNode'; } } } class UnresolvedReferenceError extends AnalysisError { /// The attempted reference that couldn't be resolved final String reference; /// A list of alternative references that would be available for [reference]. final Iterable available; UnresolvedReferenceError( {required AnalysisErrorType type, required this.reference, required this.available, AstNode? relevantNode}) : super(type: type, relevantNode: relevantNode); @override String get message { return 'Could not find $reference. Available are: ${available.join(', ')}'; } } enum AnalysisErrorType { allColumnsAreGenerated, duplicatePrimaryKeyDeclaration, writeToGeneratedColumn, referencedUnknownTable, referencedUnknownColumn, ambiguousReference, synctactic, unknownFunction, starColumnWithoutTable, compoundColumnCountMismatch, cteColumnCountMismatch, valuesSelectCountMismatch, viewColumnNamesMismatch, rowValueMisuse, notSupportedInDesiredVersion, illegalUseOfReturning, raiseMisuse, missingPrimaryKey, noTypeNameInStrictTable, invalidTypeNameInStrictTable, other, hint, } lib/src/analysis/utils/expand_function_parameters.dart 644 0 0 2445 14211667262 21501 0ustar0 pubpubpart of '../analysis.dart'; /// Extension to expand parameters defined in a sql invocation, which is either /// a [FunctionExpression] or an [AggregateFunctionInvocation]. extension ExpandParameters on SqlInvocation { /// Returns the expanded parameters of a function call. /// /// When a [StarFunctionParameter] is used, it's expanded to the /// [ReferenceScope.availableColumns]. /// Elements of the result are either an [Expression] or a [Column]. List expandParameters() { final sqlParameters = parameters; if (sqlParameters is ExprFunctionParameters) { return sqlParameters.parameters; } else if (sqlParameters is StarFunctionParameter) { // if * is used as a parameter, it refers to all columns in all tables // that are available in the current scope. final allColumns = scope.availableColumns; // When we look at `SELECT SUM(*), foo FROM ...`, the star in `SUM` // shouldn't expand to include itself. final unrelated = allColumns.where((column) { if (column is! ExpressionColumn) return true; final expression = column.expression; return !expression.selfAndDescendants.contains(this); }); return unrelated.toList(); } throw ArgumentError('Unknown parameters: $sqlParameters'); } } lib/src/analysis/options.dart 644 0 0 2137 14206504777 14430 0ustar0 pubpubpart of 'analysis.dart'; /// Options to analyze a sql statement. This can be used if the type of a /// variable is known from the outside. class AnalyzeStatementOptions { final Map indexedVariableTypes; final Map namedVariableTypes; /// Drift specific. Maps from a Dart placeholder in a query to its default /// expression, if set. final Map defaultValuesForPlaceholder; const AnalyzeStatementOptions({ this.indexedVariableTypes = const {}, this.namedVariableTypes = const {}, this.defaultValuesForPlaceholder = const {}, }); /// Looks up the defined type for that variable. /// /// Returns null if the type of that variable hasn't been set. ResolvedType? specifiedTypeOf(Variable variable) { // colon-named variables also have an index! final index = variable.resolvedIndex; if (index != null && indexedVariableTypes.containsKey(index)) { return indexedVariableTypes[index]; } else if (variable is ColonNamedVariable) { return namedVariableTypes[variable.name]; } return null; } } lib/src/analysis/schema/view.dart 644 0 0 1373 14014446300 15130 0ustar0 pubpubpart of '../analysis.dart'; /// A database view. The information stored here will be used to resolve /// references and for type inference. class View extends NamedResultSet with HasMetaMixin implements HumanReadable { @override final String name; @override final List resolvedColumns; /// The ast node that created this view final CreateViewStatement? definition; @override bool get visibleToChildren => true; /// Constructs a view from the known [name] and [resolvedColumns]. View({ required this.name, required this.resolvedColumns, this.definition, }) { for (final column in resolvedColumns) { column.view = this; } } @override String humanReadableDescription() { return name; } } lib/src/analysis/schema/from_create_table.dart 644 0 0 14464 14206505032 17641 0ustar0 pubpubpart of '../analysis.dart'; /// Reads the [Table] definition from a [CreateTableStatement]. class SchemaFromCreateTable { /// Whether we should provide additional type hints for nonstandard `BOOL` /// and `DATETIME` columns. final bool driftExtensions; const SchemaFromCreateTable({this.driftExtensions = false}); /// Reads a [Table] schema from the [stmt] inducing a table (either a /// [CreateTableStatement] or a [CreateVirtualTableStatement]). /// /// This method might throw an exception if the table could not be read. Table read(TableInducingStatement stmt) { if (stmt is CreateTableStatement) { return _readCreateTable(stmt); } else if (stmt is CreateVirtualTableStatement) { final module = stmt.scope.resolve(stmt.moduleName); if (module == null) { throw CantReadSchemaException('Unknown module "${stmt.moduleName}", ' 'did you register it?'); } return module.parseTable(stmt); } throw AssertionError('Unknown table statement'); } /// Creates a [View] from a [CreateViewStatement]. The `CREATE VIEW` statement /// must be fully resolved through [context] when calling this method. /// /// Example: /// ```dart /// // this will run analysis on the inner select statement and resolve columns /// final ctx = engine.analyze('CREATE VIEW ...'); /// final createViewStmt = ctx.root as CreateViewStatement; /// /// final view = const SchemaFromCreateTable().readView(ctx, createViewStmt); /// ``` View readView(AnalysisContext context, CreateViewStatement stmt) { final columnsFromSelect = stmt.query.resolvedColumns!; final overriddenNames = stmt.columns ?? const []; final viewColumns = []; for (var i = 0; i < columnsFromSelect.length; i++) { final column = columnsFromSelect[i]; // overriddenNames might be shorter than the columns. That's not a valid // CREATE VIEW statement, but we try not to crash. final name = i < overriddenNames.length ? overriddenNames[i] : null; viewColumns.add(ViewColumn(column, context.typeOf(column).type, name)); } return View( name: stmt.viewName, resolvedColumns: viewColumns, definition: stmt, ); } Table _readCreateTable(CreateTableStatement stmt) { final primaryKey = _primaryKeyOf(stmt); return Table( name: stmt.tableName, resolvedColumns: [ for (var def in stmt.columns) _readColumn(def, primaryKeyColumnsInStrictTable: stmt.isStrict ? primaryKey : null) ], withoutRowId: stmt.withoutRowId, isStrict: stmt.isStrict, tableConstraints: stmt.tableConstraints, definition: stmt, ); } Set _primaryKeyOf(CreateTableStatement stmt) { final columnsInPk = {}; for (final tableConstraint in stmt.tableConstraints.whereType()) { if (tableConstraint.isPrimaryKey) { for (final ref in tableConstraint.columns) { final expr = ref.expression; if (expr is Reference) { columnsInPk.add(expr.columnName); } } } } for (final column in stmt.columns) { for (final constraint in column.constraints) { if (constraint is PrimaryKeyColumn) { columnsInPk.add(column.columnName); } } } return columnsInPk; } TableColumn _readColumn(ColumnDefinition definition, {Set? primaryKeyColumnsInStrictTable}) { final type = resolveColumnType(definition.typeName); // Column is nullable if it doesn't contain a `NotNull` constraint and it's // not part of a PK in a strict table. final nullable = !definition.constraints.any((c) => c is NotNull) && primaryKeyColumnsInStrictTable?.contains(definition.columnName) != true; final resolvedType = type.withNullable(nullable); return TableColumn( definition.columnName, resolvedType, definition: definition, isGenerated: definition.constraints.any((c) => c is GeneratedAs), ); } /// Resolves a column type via its typename, see the linked rules below. /// Additionally, if [driftExtensions] are enabled, we support [IsBoolean] and /// [IsDateTime] hints if the type name contains `BOOL` or `DATE`, /// respectively. /// https://www.sqlite.org/datatype3.html#determination_of_column_affinity ResolvedType resolveColumnType(String? typeName) { if (typeName == null) { return const ResolvedType(type: BasicType.blob); } final upper = typeName.toUpperCase(); if (upper.contains('INT')) { return const ResolvedType(type: BasicType.int); } if (upper.contains('CHAR') || upper.contains('CLOB') || upper.contains('TEXT')) { return const ResolvedType(type: BasicType.text); } if (upper.contains('BLOB')) { return const ResolvedType(type: BasicType.blob); } if (driftExtensions) { if (upper.contains('BOOL')) { return const ResolvedType.bool(); } if (upper.contains('DATE')) { return const ResolvedType(type: BasicType.int, hint: IsDateTime()); } if (upper.contains('ENUM')) { return const ResolvedType(type: BasicType.int); } } return const ResolvedType(type: BasicType.real); } bool isValidTypeNameForStrictTable(String typeName) { if (driftExtensions) { // Drift_dev will use resolveColumnType to analyze the actual type of the // column, and the generated code will always use a valid type name for // that type. So, anything goes! return true; } else { // See https://www.sqlite.org/stricttables.html const allowed = {'INT', 'INTEGER', 'REAL', 'TEXT', 'BLOB', 'ANY'}; final upper = typeName.toUpperCase(); return allowed.contains(upper); } } /// Looks up the correct column affinity for a declared type name with the /// rules described here: /// https://www.sqlite.org/datatype3.html#determination_of_column_affinity @visibleForTesting BasicType? columnAffinity(String? typeName) => resolveColumnType(typeName).type; } /// Thrown when a table schema could not be read. class CantReadSchemaException implements Exception { final String message; CantReadSchemaException(this.message); @override String toString() { return 'Could not read table schema: $message'; } } lib/src/analysis/schema/references.dart 644 0 0 11412 14070050600 16306 0ustar0 pubpubpart of '../analysis.dart'; /// Mixin for classes which represent a reference. mixin ReferenceOwner { /// The resolved reference, or null if it hasn't been resolved yet. Referencable? resolved; } /// Mixin for classes which can be referenced by a [ReferenceOwner]. mixin Referencable { /// Whether this referencable is still visible in child scopes. This doesn't /// apply to many things, basically only to tables. /// /// For instance: "SELECT *, 1 AS d, (SELECT id FROM demo WHERE id = out.id) /// FROM demo AS out;" /// is a valid sql query when the demo table has an id column. However, /// "SELECT *, 1 AS d, (SELECT id FROM demo WHERE id = d) FROM demo AS out;" /// is not, the "d" referencable is not visible for the child select /// statement. bool get visibleToChildren => false; } /// Class which keeps track of references for tables, columns and functions in a /// query. class ReferenceScope { final ReferenceScope? parent; final ReferenceScope? root; /// Whether the [availableColumns] of the [parent] are available in this scope /// as well. final bool inheritAvailableColumns; /// 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 = {}; List? _availableColumns; /// All columns that would be available in this scope. Can be used to resolve /// a '*' expression for function calls or result columns List get availableColumns { if (_availableColumns != null) return _availableColumns!; if (inheritAvailableColumns) return parent!.availableColumns; return const []; } set availableColumns(List? value) { // guard against lists of subtype of column if (value != null) { _availableColumns = [...value]; } else { _availableColumns = null; } } ReferenceScope(this.parent, {this.root, this.inheritAvailableColumns = false}); void addAvailableColumn(Column column) { // make sure _availableColumns is resolved and mutable final ownColumns = _availableColumns ??= [...availableColumns]; ownColumns.add(column); } ReferenceScope createChild({bool? inheritAvailableColumns}) { // 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, inheritAvailableColumns: inheritAvailableColumns ?? false, ); } ReferenceScope createSibling() { return parent!.createChild(); } /// Registers something that can be referenced in this and child scopes. void register(String identifier, Referencable ref) { _references.putIfAbsent(identifier.toUpperCase(), () => []).add(ref); } /// Registers both a [TableAlias] and a [ResultSetAvailableInStatement] so /// that the alias can be used in expressions without being selected. void registerUsableAlias(AstNode origin, ResultSet resultSet, String alias) { final createdAlias = TableAlias(resultSet, alias); register(alias, createdAlias); register(alias, ResultSetAvailableInStatement(origin, createdAlias)); } /// 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}) { ReferenceScope? 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.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() { ReferenceScope? scope = this; var isInCurrentScope = true; final collected = []; while (scope != null) { var foundValues = scope._references.values.expand((list) => list).whereType(); if (!isInCurrentScope) { foundValues = foundValues.where((element) => element.visibleToChildren).cast(); } collected.addAll(foundValues); scope = scope.parent; isInCurrentScope = false; } return collected; } } lib/src/analysis/schema/result_set.dart 644 0 0 4545 14070050600 16347 0ustar0 pubpubpart of '../analysis.dart'; /// Something that will resolve to an [ResultSet] when referred to via /// the [ReferenceScope]. abstract class ResolvesToResultSet with Referencable { ResultSet? get resultSet; } /// Something that returns a set of columns when evaluated. abstract class ResultSet implements ResolvesToResultSet { /// The columns that will be returned when evaluating this query. List? get resolvedColumns; @override ResultSet get resultSet => this; @override bool get visibleToChildren => false; Column? findColumn(String name) { return resolvedColumns!.firstWhereOrNull((c) => c.name == name); } } /// A custom result set that has columns but isn't a table. class CustomResultSet with ResultSet { @override final List resolvedColumns; CustomResultSet(this.resolvedColumns); } /// Something that returns a set of Columns and can be referenced by a name, /// such as a table or a view. abstract class NamedResultSet extends ResultSet { /// The name of this result set, as it appears in sql statements. This should /// be the raw name, not an escaped version. /// /// To obtain an escaped name, use [escapedName]. String get name; /// If [name] is a reserved sql keyword, wraps it in double ticks. Otherwise /// just returns the [name] directly. String get escapedName { return isKeywordLexeme(name) ? '"$name"' : name; } } /// Information about a result set that is available in a statement. /// /// Regular result sets include tables or views that are available globally. /// However, columns from those result sets can't be used in statements unless /// the result set appears in a `FROM` clause or a similar construct. /// /// This class stores information about added result sets and the syntactic /// construct that added them. class ResultSetAvailableInStatement with Referencable { /// The node responsible for adding the [resultSet]. /// /// This may typically be a [TableOrSubquery] appearing a `FROM` clause. final AstNode origin; /// The added result set. final ResolvesToResultSet resultSet; @override bool get visibleToChildren => true; ResultSetAvailableInStatement(this.origin, this.resultSet); } extension UnaliasResultSet on ResultSet { ResultSet unalias() { var $this = this; while ($this is TableAlias) { $this = $this.delegate; } return $this; } } lib/src/analysis/schema/table.dart 644 0 0 6232 14155120333 15245 0ustar0 pubpubpart of '../analysis.dart'; /// The aliases which can be used to refer to the rowid of a table. See /// https://www.sqlite.org/lang_createtable.html#rowid const aliasesForRowId = ['rowid', 'oid', '_rowid_']; /// A database table. The information stored here will be used to resolve /// references and for type inference. class Table extends NamedResultSet with HasMetaMixin implements HumanReadable { /// The name of this table, as it appears in sql statements. This should be /// the raw name, not an escaped version. /// /// To obtain an escaped name, use [escapedName]. @override final String name; @override final List resolvedColumns; /// Filter the [resolvedColumns] for those that are /// [Column.includedInResults]. List get resultColumns => resolvedColumns.where((c) => c.includedInResults).toList(); /// Whether this table was created with an "WITHOUT ROWID" modifier final bool withoutRowId; final bool isStrict; /// Additional constraints set on this table. final List tableConstraints; /// The ast node that created this table final TableInducingStatement? definition; /// Whether this is a virtual table. final bool isVirtual; @override bool get visibleToChildren => true; TableColumn? _rowIdColumn; /// Constructs a table from the known [name] and [resolvedColumns]. Table({ required this.name, required this.resolvedColumns, this.withoutRowId = false, this.isStrict = false, this.tableConstraints = const [], this.definition, this.isVirtual = false, }) { for (final column in resolvedColumns) { column.table = this; if (_rowIdColumn == null && column.isAliasForRowId()) { _rowIdColumn = column; // By design, the rowid is non-nullable, even if there isn't a NOT NULL // constraint set on the column definition. column._type = const ResolvedType(type: BasicType.int, nullable: false); } } } @override Column? findColumn(String name) { final defaultSearch = super.findColumn(name); if (defaultSearch != null) return defaultSearch; // handle aliases to rowids, see https://www.sqlite.org/lang_createtable.html#rowid if (aliasesForRowId.contains(name.toLowerCase()) && !withoutRowId) { return _rowIdColumn ?? RowId() ..table = this; } return null; } @override String humanReadableDescription() { return name; } } class TableAlias extends NamedResultSet implements HumanReadable { final ResultSet delegate; final String alias; TableAlias(this.delegate, this.alias); @override String get name => alias; @override List get resolvedColumns => delegate.resolvedColumns!; @override Column? findColumn(String name) => delegate.findColumn(name); @override ResultSet get resultSet => this; @override bool get visibleToChildren => delegate.visibleToChildren; @override String humanReadableDescription() { final delegateDescription = delegate is HumanReadable ? (delegate as HumanReadable).humanReadableDescription() : delegate.toString(); return '$alias (alias to $delegateDescription)'; } } lib/src/analysis/schema/column.dart 644 0 0 21403 14206510571 15474 0ustar0 pubpubpart of '../analysis.dart'; /// A column that appears in a [ResultSet]. Has a type and a name. abstract class Column with Referencable, HasMetaMixin implements Typeable, HumanReadable { /// The name of this column in the result set. String get name; /// Whether this column is included in results when running a select query /// like `SELECT * FROM table`. /// /// Some columns, notably the rowid aliases, are exempt from this. bool get includedInResults => true; /// The result set containing this column, or null if this column is not part /// of a known result set. ResultSet? containingSet; @override String humanReadableDescription() { return name; } } /// A column that has a statically known resolved type. abstract class ColumnWithType implements Column { /// The type of this column, which is available before any resolution happens /// (we know it from the schema structure). ResolvedType? get type; } /// A column that is part of a table. class TableColumn extends Column implements ColumnWithType { @override final String name; /// Whether this column was created with a `GENERATED ALWAYS AS` column /// constraint. /// /// Generated columns can't be inserted or updated. final bool isGenerated; @override ResultSet? get containingSet => table; @override ResolvedType get type => _type; ResolvedType _type; /// The column constraints set on this column. /// /// This only works columns where [hasDefinition] is true, otherwise this /// getter will throw. The columns in a `CREATE TABLE` statement always have /// a definition, but those from a `CREATE VIRTUAL TABLE` likely don't. /// /// See also: /// - https://www.sqlite.org/syntax/column-constraint.html List get constraints => definition!.constraints; /// The definition in the AST that was used to create this column model. final ColumnDefinition? definition; /// Whether this column has a definition from the ast. bool get hasDefinition => definition != null; /// The table this column belongs to. Table? table; late final bool _isAliasForRowId = _computeIsAliasForRowId(); TableColumn(this.name, this._type, {this.definition, this.isGenerated = false}); /// Applies a type hint to this column. /// /// The [hint] will then be reflected in the [type]. void applyTypeHint(TypeHint hint) { _type = _type.copyWith(hint: hint); } /// Whether this column is an alias for the rowid, as defined in /// https://www.sqlite.org/lang_createtable.html#rowid /// /// To summarize, a column is an alias for the rowid if all of the following /// conditions are met: /// - the table has a primary key that consists of exactly one (this) column /// - the column is declared to be an integer /// - if this column has a [PrimaryKeyColumn], the [OrderingMode] of that /// constraint is not [OrderingMode.descending]. bool isAliasForRowId() { return _isAliasForRowId; } bool _computeIsAliasForRowId() { if (definition == null || table == null || type.type != BasicType.int || table!.withoutRowId) { return false; } // We need to check whether this column is a primary key, which could happen // because of a table or a column constraint final columnsWithKey = table!.tableConstraints.whereType(); for (final tableConstraint in columnsWithKey) { if (!tableConstraint.isPrimaryKey) continue; final columns = tableConstraint.columns; if (columns.length != 1) continue; final singleColumnExpr = columns.single.expression; if (singleColumnExpr is Reference && singleColumnExpr.columnName == name) { return true; } } // option 2: This column has a primary key constraint for (final primaryConstraint in constraints.whereType()) { if (primaryConstraint.mode == OrderingMode.descending) return false; // additional restriction: Column type must be exactly "INTEGER" return definition!.typeName == 'INTEGER'; } return false; } @override String humanReadableDescription() { return '$name in ${table!.humanReadableDescription()}'; } } /// A column that is part of a view. class ViewColumn extends Column with DelegatedColumn implements ColumnWithType { final String? _name; @override final ResolvedType? type; @override final Column innerColumn; @override ResultSet? get containingSet => view; /// The view this column belongs to. View? view; /// Creates a view column wrapping a [Column] from the select statement used /// to create the view. /// /// The optional name parameter can be used to override the name for this /// column. By default, the name of the [innerColumn] will be used. ViewColumn(this.innerColumn, this.type, [this._name]); @override String get name => _name ?? super.name; @override String humanReadableDescription() { return '$name in ${view!.humanReadableDescription()}'; } } /// Refers to the special "rowid", "oid" or "_rowid_" column defined for tables /// that weren't created with an `WITHOUT ROWID` clause. class RowId extends TableColumn { // note that such alias is always called "rowid" in the result set - // "SELECT oid FROM table" yields a sinle column called "rowid" RowId() : super('rowid', const ResolvedType(type: BasicType.int)); @override bool get includedInResults => false; } /// A column that is created by an expression. For instance, in the select /// statement "SELECT 1 + 3", there is a column called "1 + 3" of type int. class ExpressionColumn extends Column { @override final String name; /// The expression returned by this column. final Expression expression; ExpressionColumn({required this.name, required this.expression}); } /// A column that is created by a reference expression. The difference to an /// [ExpressionColumn] is that the correct case of the column name depends on /// the resolved reference. class ReferenceExpressionColumn extends ExpressionColumn { Reference? get reference => expression as Reference?; @override String get name { return overriddenName ?? reference!.resolvedColumn?.name ?? // The resolved column might not have been resolved yet. Use the // syntactic name from the reference as a fallback: It's only different // for rowid references, and those are easier to resolve. reference!.columnName; } final String? overriddenName; ReferenceExpressionColumn(Reference ref, {this.overriddenName}) : super(name: '_', expression: ref); } /// A column that wraps another column. mixin DelegatedColumn on Column { Column? get innerColumn; @override String get name => innerColumn!.name; @override bool get includedInResults => innerColumn?.includedInResults ?? true; } /// The result column of a [CompoundSelectStatement]. class CompoundSelectColumn extends Column with DelegatedColumn { /// The column in [CompoundSelectStatement.base] each of the /// [CompoundSelectStatement.additional] that contributed to this column. final List columns; CompoundSelectColumn(this.columns); @override Column get innerColumn => columns.first; } class CommonTableExpressionColumn extends Column with DelegatedColumn { @override final String name; @override Column? innerColumn; // note that innerColumn is mutable because the column might not be known // during all analysis phases. CommonTableExpressionColumn(this.name, [this.innerColumn]); } /// Result column coming from a `VALUES` select statement. class ValuesSelectColumn extends Column { @override final String name; /// The expressions from a `VALUES` clause contributing to this column. /// /// Essentially, each [ValuesSelectColumn] consists of a column in the values /// of a [ValuesSelectStatement]. final List expressions; ValuesSelectColumn(this.name, this.expressions) : assert(expressions.isNotEmpty); } /// A column that is available in the scope of a statement. /// /// In addition to the [innerColumn], this provides the [source] which brought /// this column into scope. This can be used to determine nullability. class AvailableColumn extends Column with DelegatedColumn { @override final Column innerColumn; final ResultSetAvailableInStatement source; AvailableColumn(this.innerColumn, this.source); } extension UnaliasColumn on Column { /// Attempts to resolve the source of this column, if this is an /// [AvailableColumn] or a [CommonTableExpressionColumn] that refers to /// another column. Column get source { var current = this; while (current is DelegatedColumn) { final inner = current.innerColumn; if (inner != null) { current = inner; } else { return current; } } return current; } } lib/src/analysis/analysis.dart 644 0 0 1776 14200761154 14554 0ustar0 pubpubimport 'dart:math' show max; import 'package:collection/collection.dart' show IterableExtension; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; // hiding because of http://dartbug.com/39263 import 'package:sqlparser/sqlparser.dart' hide ExpandParameters; import 'package:sqlparser/src/utils/meta.dart'; export 'types/data.dart'; export 'types/types.dart' show TypeInferenceResults; part 'context.dart'; part 'error.dart'; part 'options.dart'; part 'schema/column.dart'; part 'schema/from_create_table.dart'; part 'schema/references.dart'; part 'schema/result_set.dart'; part 'schema/table.dart'; part 'schema/view.dart'; part 'steps/column_resolver.dart'; part 'steps/linting_visitor.dart'; part 'steps/prepare_ast.dart'; part 'steps/reference_resolver.dart'; part 'steps/set_parent_visitor.dart'; part 'utils/expand_function_parameters.dart'; /// Something that can be represented in a human-readable description. abstract class HumanReadable { String humanReadableDescription(); } lib/src/analysis/steps/column_resolver.dart 644 0 0 36214 14200761154 17320 0ustar0 pubpubpart of '../analysis.dart'; /// Walks the AST and, for each select statement it sees, finds out which /// columns are returned and which columns are available. For instance, when /// we have a table "t" with two columns "a" and "b", the select statement /// "SELECT a FROM t" has one result column but two columns available. class ColumnResolver extends RecursiveVisitor { final AnalysisContext context; ColumnResolver(this.context); @override void visitSelectStatement(SelectStatement e, void arg) { // visit children first so that common table expressions are resolved visitChildren(e, arg); _resolveSelect(e); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { // first, visit all children so that the compound parts have their columns // resolved visitChildren(e, arg); _resolveCompoundSelect(e); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { // visit children to resolve CTEs visitChildren(e, arg); _resolveValuesSelect(e); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { visitChildren(e, arg); final resolved = e.as.resolvedColumns; final names = e.columnNames; if (names != null && resolved != null && names.length != resolved.length) { context.reportError(AnalysisError( type: AnalysisErrorType.cteColumnCountMismatch, message: 'This CTE declares ${names.length} columns, but its select ' 'statement actually returns ${resolved.length}.', relevantNode: e, )); } } @override void visitDoUpdate(DoUpdate e, void arg) { final surroundingInsert = e.parents.whereType().first; final table = surroundingInsert.table.resultSet; if (table != null) { // add "excluded" table qualifier that referring to the row that would // have been inserted had the uniqueness constraint not been violated. e.scope.registerUsableAlias(e, table, 'excluded'); } visitChildren(e, arg); } @override void visitTableReference(TableReference e, void arg) { if (e.resolved == null) { _resolveTableReference(e); } } @override void visitUpdateStatement(UpdateStatement e, void arg) { final availableColumns = []; // Add columns from the main table, if it was resolved _handle(e.table, availableColumns); // Also add columns from a FROM clause, if one is present final from = e.from; if (from != null) _handle(from, availableColumns); e.scope.availableColumns = availableColumns; for (final child in e.childNodes) { // Visit remaining children if (child != e.table && child != e.from) visit(child, arg); } _resolveReturningClause(e, e.table.resultSet); } ResultSet? _addIfResolved(AstNode node, TableReference ref) { final table = _resolveTableReference(ref); if (table != null) { node.scope.availableColumns = table.resolvedColumns; } return table; } @override void visitInsertStatement(InsertStatement e, void arg) { final into = _addIfResolved(e, e.table); visitChildren(e, arg); _resolveReturningClause(e, into); } @override void visitDeleteStatement(DeleteStatement e, void arg) { final from = _addIfResolved(e, e.from); visitChildren(e, arg); _resolveReturningClause(e, from); } /// Infers the result set of a `RETURNING` clause. /// /// The behavior of `RETURNING` clauses is a bit weird when there are multiple /// tables available (which can happen with `UPDATE FROM`). When a star column /// is used, it only expands to columns from the main table: /// ```sql /// CREATE TABLE x (a, b); /// -- here, the `*` in returning does not include columns from `old`. /// UPDATE x SET a = x.a + 1 FROM (SELECT * FROM x) AS old RETURNING *; /// ``` /// /// However, individual columns from other tables are available and supported: /// ```sql /// UPDATE x SET a = x.a + 1 FROM (SELECT * FROM x) AS old /// RETURNING old.a, old.b; /// ``` /// /// Note that `old.*` is forbidden by sqlite and not applicable here. void _resolveReturningClause( StatementReturningColumns stmt, ResultSet? mainTable) { final clause = stmt.returning; if (clause == null) return; final columns = _resolveColumns(stmt.scope, clause.columns, columnsForStar: mainTable?.resolvedColumns); stmt.returnedResultSet = CustomResultSet(columns); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final table = _resolveTableReference(e.onTable); if (table == null) { // further analysis is not really possible without knowing the table super.visitCreateTriggerStatement(e, arg); return; } final scope = e.scope; // Add columns of the target table for when and update of clauses scope.availableColumns = table.resolvedColumns; if (e.target.introducesNew) { scope.registerUsableAlias(e, table, 'new'); } if (e.target.introducesOld) { scope.registerUsableAlias(e, table, 'old'); } visitChildren(e, arg); } void _handle(Queryable queryable, List availableColumns) { void addColumns(Iterable columns) { ResultSetAvailableInStatement? available; if (queryable is TableOrSubquery) { available = queryable.availableResultSet; } if (available != null) { availableColumns.addAll( [for (final column in columns) AvailableColumn(column, available)]); } else { availableColumns.addAll(columns); } } queryable.when( isTable: (table) { final resolved = _resolveTableReference(table); if (resolved != null) { // an error will be logged when resolved is null, so the != null check // is fine and avoids crashes addColumns(table.resultSet!.resolvedColumns!); } }, isSelect: (select) { // the inner select statement doesn't have access to columns defined in // the outer statements, which is why we use _resolveSelect instead of // passing availableColumns down to a recursive call of _handle final stmt = select.statement; if (stmt is CompoundSelectStatement) { _resolveCompoundSelect(stmt); } else if (stmt is SelectStatement) { _resolveSelect(stmt); } else if (stmt is ValuesSelectStatement) { _resolveValuesSelect(stmt); } else { throw AssertionError('Unknown type of select statement: $stmt'); } addColumns(stmt.resolvedColumns!); }, isJoin: (join) { _handle(join.primary, availableColumns); for (final query in join.joins.map((j) => j.query)) { _handle(query, availableColumns); } }, isTableFunction: (function) { final handler = context .engineOptions.addedTableFunctions[function.name.toLowerCase()]; final resolved = handler?.resolveTableValued(context, function); if (resolved == null) { context.reportError(AnalysisError( type: AnalysisErrorType.unknownFunction, message: 'Could not extract the result set for this table function', relevantNode: function, )); } else { function.resultSet = resolved; addColumns(resolved.resolvedColumns!); } }, ); } void _resolveSelect(SelectStatement s) { final availableColumns = []; if (s.from != null) { _handle(s.from!, availableColumns); } final scope = s.scope; scope.availableColumns = availableColumns; s.resolvedColumns = _resolveColumns(scope, s.columns); } List _resolveColumns(ReferenceScope scope, List columns, {List? columnsForStar}) { final usedColumns = []; final availableColumns = [...scope.availableColumns]; // a select statement can include everything from its sub queries as a // result, but also expressions that appear as result columns for (final resultColumn in columns) { if (resultColumn is StarResultColumn) { Iterable? visibleColumnsForStar; if (resultColumn.tableName != null) { final tableResolver = scope.resolve( resultColumn.tableName!, orElse: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); }); if (tableResolver == null) continue; visibleColumnsForStar = tableResolver.resultSet.resultSet?.resolvedColumns?.map( (tableColumn) => AvailableColumn(tableColumn, tableResolver)); } else { // we have a * column without a table, that resolves to every column // available visibleColumnsForStar = columnsForStar ?? availableColumns; // Star columns can't be used without a table (e.g. `SELECT *` is // not allowed) if (scope.allOf().isEmpty) { context.reportError(AnalysisError( type: AnalysisErrorType.starColumnWithoutTable, message: "Can't use * when no tables have been added", relevantNode: resultColumn, )); } } usedColumns .addAll(visibleColumnsForStar!.where((e) => e.includedInResults)); } else if (resultColumn is ExpressionResultColumn) { final expression = resultColumn.expression; Column column; if (expression is Reference) { column = ReferenceExpressionColumn(expression, overriddenName: resultColumn.as); } else { final name = _nameOfResultColumn(resultColumn)!; column = ExpressionColumn(name: name, expression: resultColumn.expression); } usedColumns.add(column); if (resultColumn.as != null) { // make this column available for references if there is no other // column with the same name final name = resultColumn.as; if (!availableColumns.any((c) => c.name == name)) { availableColumns.add(column); scope.addAvailableColumn(column); } } } else if (resultColumn is NestedStarResultColumn) { final target = scope.resolve( resultColumn.tableName, orElse: () { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table: ${resultColumn.tableName}', relevantNode: resultColumn, )); }); if (target != null) resultColumn.resultSet = target.resultSet.resultSet; } else if (resultColumn is NestedQueryColumn) { _resolveSelect(resultColumn.select); } } return usedColumns; } void _resolveCompoundSelect(CompoundSelectStatement statement) { final columnSets = [ statement.base.resolvedColumns, for (var part in statement.additional) part.select.resolvedColumns ]; // each select statement must return the same amount of columns final amount = columnSets.first!.length; for (var i = 1; i < columnSets.length; i++) { if (columnSets[i]!.length != amount) { context.reportError(AnalysisError( type: AnalysisErrorType.compoundColumnCountMismatch, relevantNode: statement, message: 'The parts of this compound statement return different ' 'amount of columns', )); break; } } final resolved = []; // merge all columns at each position into a CompoundSelectColumn for (var i = 0; i < amount; i++) { final columnsAtThisIndex = [ for (var set in columnSets) if (set!.length > i) set[i] ]; resolved.add( CompoundSelectColumn(columnsAtThisIndex)..containingSet = statement); } statement.resolvedColumns = resolved; } void _resolveValuesSelect(ValuesSelectStatement statement) { // ideally all tuples should have the same arity, but the parser doesn't // enforce that. final amountOfColumns = statement.values.fold(null, (maxLength, tuple) { final lengthHere = tuple.expressions.length; return maxLength == null ? lengthHere : max(maxLength, lengthHere); })!; final columns = []; for (var i = 0; i < amountOfColumns; i++) { // Columns in a VALUES clause appear to be named "Column$i", where i is a // one-based index. final columnName = 'Column${i + 1}'; final expressions = statement.values .where((tuple) => tuple.expressions.length > i) .map((tuple) => tuple.expressions[i]) .toList(); columns.add(ValuesSelectColumn(columnName, expressions) ..containingSet = statement); } statement.resolvedColumns = columns; } String? _nameOfResultColumn(ExpressionResultColumn c) { if (c.as != null) return c.as; if (c.expression is Reference) { return (c.expression as Reference).columnName; } // in this case it's just the literal expression. So for instance, // "SELECT 3+ 5" has a result column called "3+ 5" (consecutive whitespace // is removed). final span = context.sql.substring(c.firstPosition, c.lastPosition); // todo remove consecutive whitespace return span; } ResultSet? _resolveTableReference(TableReference r) { final scope = r.scope; // Try resolving to a top-level table in the schema and to a result set that // may have been added to the table final resolvedInSchema = scope.resolve(r.tableName); final resolvedInQuery = scope.resolve(r.tableName); final createdName = r.as; // Prefer using a table that has already been added if this isn't the // definition of the added table reference if (resolvedInQuery != null && resolvedInQuery.origin != r) { final resolved = resolvedInQuery.resultSet.resultSet; if (resolved != null) { return r.resolved = createdName != null ? TableAlias(resolved, createdName) : resolved; } } else if (resolvedInSchema != null) { return r.resolved = createdName != null ? TableAlias(resolvedInSchema, createdName) : resolvedInSchema; } else { final available = scope .allOf() .followedBy(scope .allOf() .map((added) => added.resultSet)) .where((e) => e.resultSet != null) .map((t) { final resultSet = t.resultSet; if (resultSet is HumanReadable) { return (resultSet as HumanReadable).humanReadableDescription(); } return t.toString(); }); context.reportError(UnresolvedReferenceError( type: AnalysisErrorType.referencedUnknownTable, relevantNode: r, reference: r.tableName, available: available, )); } return null; } } lib/src/analysis/steps/reference_resolver.dart 644 0 0 11301 14211623725 17752 0ustar0 pubpubpart of '../analysis.dart'; /// Resolves any open [Reference] it finds in the AST. class ReferenceResolver extends RecursiveVisitor { final AnalysisContext context; ReferenceResolver(this.context); @override void visitInsertStatement(InsertStatement e, void arg) { final table = e.table.resultSet; if (table != null) { // Resolve columns in the main table for (final column in e.targetColumns) { _resolveReferenceInTable(column, table); } } visitChildren(e, arg); } @override void visitForeignKeyClause(ForeignKeyClause e, void arg) { final table = e.foreignTable.resultSet; if (table == null) { // If the table wasn't found, an earlier step will have reported an error return super.visitForeignKeyClause(e, arg); } for (final columnName in e.columnNames) { _resolveReferenceInTable(columnName, table); } } @override void visitReference(Reference e, void arg) { if (e.resolved != null) { return super.visitReference(e, arg); } final scope = e.scope; if (e.entityName != null) { // first find the referenced table or view, // then use the column on that table or view. final entityResolver = scope.resolve(e.entityName!); final resultSet = entityResolver?.resultSet.resultSet; if (resultSet == null) { context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownTable, message: 'Unknown table or view: ${e.entityName}', relevantNode: e, )); } else { _resolveReferenceInTable(e, resultSet, source: entityResolver); } } else if (aliasesForRowId.contains(e.columnName.toLowerCase())) { // special case for aliases to a rowid final column = _resolveRowIdAlias(e); if (column == null) { _reportUnknownColumnError(e); } else { e.resolved = column; } } else { // find any column with the referenced name. // todo special case for USING (...) in joins? final columns = scope.availableColumns.where((c) => c.name == e.columnName).toSet(); if (columns.isEmpty) { _reportUnknownColumnError(e); } else { if (columns.length > 1) { final description = columns.map((c) => c.humanReadableDescription()).join(', '); context.reportError(AnalysisError( type: AnalysisErrorType.ambiguousReference, relevantNode: e, message: 'Could refer to any of: $description', )); } e.resolved = columns.first; } } visitChildren(e, arg); } @override void visitUpdateStatement(UpdateStatement e, void arg) { final table = e.table.resultSet; if (table != null) { // Resolve the set components against the primary table for (final set in e.set) { _resolveReferenceInTable(set.column, table); } } visitChildren(e, arg); } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { if (e.windowName != null && e.resolved == null) { final resolved = e.scope.resolve(e.windowName!); e.resolved = resolved; } visitChildren(e, arg); } void _reportUnknownColumnError(Reference e, {Iterable? columns}) { columns ??= e.scope.availableColumns; final columnNames = e.scope.availableColumns .map((c) => c.humanReadableDescription()) .join(', '); context.reportError(AnalysisError( type: AnalysisErrorType.referencedUnknownColumn, relevantNode: e, message: 'Unknown column. These columns are available: $columnNames', )); } void _resolveReferenceInTable(Reference ref, ResultSet resultSet, {ResultSetAvailableInStatement? source}) { var column = resultSet.findColumn(ref.columnName); if (column == null) { _reportUnknownColumnError(ref, columns: resultSet.resolvedColumns); } else { if (source != null) { column = AvailableColumn(column, source); } ref.resolved = column; ref.resultEntity = source; } } Column? _resolveRowIdAlias(Reference e) { // to resolve those aliases when they're not bound to a table, the // surrounding statement may only read from one table final stmt = e.enclosingOfType(); if (stmt == null) return null; final from = stmt.table; if (from is! TableReference) { return null; } final resolved = from.resultSet?.unalias(); if (resolved is! Table) return null; // table.findColumn contains logic to resolve row id aliases return resolved.findColumn(e.columnName); } } lib/src/analysis/steps/set_parent_visitor.dart 644 0 0 570 14000111271 17744 0ustar0 pubpubpart of '../analysis.dart'; /// Sets the [AstNode.parent] property for each node in a tree. class SetParentVisitor { const SetParentVisitor(); void startAtRoot(AstNode root) { _applyFor(root, null); } void _applyFor(AstNode node, AstNode? parent) { node.parent = parent; for (final child in node.childNodes) { _applyFor(child, node); } } } lib/src/analysis/steps/prepare_ast.dart 644 0 0 21765 14206505250 16413 0ustar0 pubpubpart of '../analysis.dart'; /// Prepares the AST for further analysis. This visitor /// - creates [ReferenceScope]s for sub-queries /// - in each scope, registers every table or subquery that can be referenced to /// the local [ReferenceScope]. /// - determines the [Variable.resolvedIndex] for each [Variable] in this /// statement. /// - reports syntactic errors that aren't handled in the parser to keep that /// implementation simpler. class AstPreparingVisitor extends RecursiveVisitor { final List _foundVariables = []; final AnalysisContext context; AstPreparingVisitor({required this.context}); void start(AstNode root) { root.accept(this, null); resolveIndexOfVariables(_foundVariables); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final scope = e.scope = e.scope.createChild(); final registeredTable = scope.resolve(e.tableName) as Table?; // This is used so that tables can refer to their own columns. Code using // tables would first register the table and then run analysis again. if (registeredTable != null) { scope.availableColumns = registeredTable.resolvedColumns; for (final column in registeredTable.resolvedColumns) { scope.register(column.name, column); } } visitChildren(e, arg); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { e.scope = e.scope.createChild(); visitChildren(e, arg); } @override void visitSelectStatement(SelectStatement e, void arg) { // a select statement can appear as a sub query which has its own scope, so // we need to fork the scope here. There is one special case though: // Select statements that appear as a query source can't depend on data // defined in the outer scope. This is different from select statements // that work as expressions. // For instance, if you go to sqliteonline.com and issue the following // query: "SELECT * FROM demo d1, // (SELECT * FROM demo i WHERE i.id = d1.id) d2;" // it won't work. final isInFROM = e.parent is Queryable; final scope = e.scope; if (isInFROM) { final surroundingSelect = e.parents.firstWhere((node) => node is HasFrom).scope; final forked = surroundingSelect.createSibling(); e.scope = forked; } else { final forked = scope.createChild(); e.scope = forked; } for (final windowDecl in e.windowDeclarations) { e.scope.register(windowDecl.name, windowDecl); } // only the last statement in a compound select statement may have an order // by or a limit clause if (e.parent is CompoundSelectPart || e.parent is CompoundSelectStatement) { bool isLast; if (e.parent is CompoundSelectPart) { final part = e.parent as CompoundSelectPart; final compoundSelect = part.parent as CompoundSelectStatement; final index = compoundSelect.additional.indexOf(part); isLast = index == compoundSelect.additional.length - 1; } else { // if the parent is the compound select statement, this select query is // the [CompoundSelectStatement.base], so definitely not the last query. isLast = false; } if (!isLast) { if (e.limit != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Limit clause must appear in the last compound statement', relevantNode: e.limit, )); } if (e.orderBy != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Order by clause must appear in the compound statement', relevantNode: e.orderBy, )); } } } visitChildren(e, arg); } @override void visitResultColumn(ResultColumn e, void arg) { if (e is StarResultColumn) { // doesn't need special treatment, star expressions can't be referenced } else if (e is ExpressionResultColumn) { if (e.as != null) { e.scope.register(e.as!, e); } } visitChildren(e, arg); } @override void defaultQueryable(Queryable e, void arg) { final scope = e.scope; e.when( isTable: (table) { final added = ResultSetAvailableInStatement(table, table); table.availableResultSet = added; scope.register(table.as ?? table.tableName, added); }, isSelect: (select) { if (select.as != null) { final added = ResultSetAvailableInStatement(select, select.statement); select.availableResultSet = added; scope.register(select.as!, added); } }, 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. }, isTableFunction: (function) { final added = ResultSetAvailableInStatement(function, function); function.availableResultSet = added; scope.register(function.as ?? function.name, added); }, ); visitChildren(e, arg); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { e.scope.register(e.cteTableName, e); visitChildren(e, arg); } @override void visitNumberedVariable(NumberedVariable e, void arg) { _foundVariables.add(e); visitChildren(e, arg); } @override void visitNamedVariable(ColonNamedVariable e, void arg) { _foundVariables.add(e); visitChildren(e, arg); } static void resolveIndexOfVariables(List variables) { // sort variables by the order in which they appear inside the statement. variables.sort((a, b) { return a.firstPosition.compareTo(b.firstPosition); }); // Assigning rules are explained at https://www.sqlite.org/lang_expr.html#varparam var largestAssigned = 0; final resolvedNames = {}; for (final variable in variables) { if (variable is NumberedVariable) { // if the variable has an explicit index (e.g ?123), then 123 is the // resolved index and the next variable will have index 124. Otherwise, // just assigned the current largest assigned index plus one. if (variable.explicitIndex != null) { final index = variable.resolvedIndex = variable.explicitIndex!; largestAssigned = max(largestAssigned, index); } else { variable.resolvedIndex = largestAssigned + 1; largestAssigned++; } } else if (variable is ColonNamedVariable) { // named variables behave just like numbered vars without an explicit // index, but of course two variables with the same name must have the // same index. final index = resolvedNames.putIfAbsent(variable.name, () { return ++largestAssigned; }); variable.resolvedIndex = index; } } } void _forkScope(AstNode node, {bool? inheritAvailableColumns}) { node.scope = node.scope .createChild(inheritAvailableColumns: inheritAvailableColumns); } @override void defaultNode(AstNode e, void arg) { // hack to fork scopes on statements (selects are handled above) if (e is Statement && e is! SelectStatement) { _forkScope(e); } visitChildren(e, arg); } @override void visitUpsertClause(UpsertClause e, void arg) { for (var i = 0; i < e.entries.length; i++) { _visitUpsertClauseEntry(e.entries[i], i == e.entries.length - 1); } } void _visitUpsertClauseEntry(UpsertClauseEntry e, bool isLast) { // Every DoUpdate except for the last ON CONFLICT clause must have a // conflict target. When using older sqlite versions, every clause needs // a conflict target. final lastWithoutTargetOk = context.engineOptions.version >= SqliteVersion.v3_35; final withoutTargetOk = lastWithoutTargetOk && isLast; if (e.onColumns == null && e.action is DoUpdate && !withoutTargetOk) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Expected a conflict clause when using DO UPDATE', relevantNode: e.action, )); } // DO UPDATE clauses have their own reference scope, in which the row // "excluded" can be referred. Setting that row happens in the column // resolver if (e.action is DoUpdate) { _forkScope(e.action, inheritAvailableColumns: true); } visitChildren(e, null); } /// If a nested query was found. Collect everything separately. @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is NestedQueryColumn) { // create a new scope for the nested query to differentiate between // references that can be resolved in the nested query and references // which require data from the parent query e.select.scope = e.scope.createChild(); AstPreparingVisitor(context: context).start(e.select); } else { super.visitDriftSpecificNode(e, arg); } } } lib/src/analysis/steps/linting_visitor.dart 644 0 0 34735 14211623660 17334 0ustar0 pubpubpart of '../analysis.dart'; /// Visitor that runs after all other steps ran and reports more complex lints /// on an sql statement. class LintingVisitor extends RecursiveVisitor { final EngineOptions options; final AnalysisContext context; bool _isTopLevelStatement = true; LintingVisitor(this.options, this.context); @override void visitBinaryExpression(BinaryExpression e, void arg) { final operator = e.operator.type; if ((operator == TokenType.dashRangle || operator == TokenType.dashRangleRangle) && options.version < SqliteVersion.v3_38) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: '`->` and `->>` require sqlite3 version 38', relevantNode: e.operator, )); } visitChildren(e, arg); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { if (e.materializationHint != null && options.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'MATERIALIZED / NOT MATERIALIZED requires sqlite3 version 35', relevantNode: e.materialized ?? e, )); } visitChildren(e, arg); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final schemaReader = SchemaFromCreateTable(driftExtensions: options.useDriftExtensions); var hasNonGeneratedColumn = false; var hasPrimaryKeyDeclaration = false; var isStrict = false; if (e.isStrict) { if (options.version < SqliteVersion.v3_37) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'STRICT tables are only supported from sqlite3 version 37', relevantNode: e.strict ?? e, )); } else { // only report warnings related to STRICT tables if strict tables are // supported. isStrict = true; } } // Ensure that a table declaration only has one PRIMARY KEY constraint void handlePrimaryKeyNode(AstNode node) { if (hasPrimaryKeyDeclaration) { context.reportError(AnalysisError( type: AnalysisErrorType.duplicatePrimaryKeyDeclaration, message: 'Duplicate PRIMARY KEY constraint found', relevantNode: node, )); } hasPrimaryKeyDeclaration = true; } for (final column in e.columns) { if (isStrict) { final typeName = column.typeName; if (typeName == null) { // Columns in strict tables must have a type name, even if it's // `ANY`. context.reportError(AnalysisError( type: AnalysisErrorType.noTypeNameInStrictTable, message: 'In `STRICT` tables, columns must have a type name!', relevantNode: column.nameToken ?? column, )); } else if (!schemaReader.isValidTypeNameForStrictTable(typeName)) { context.reportError(AnalysisError( type: AnalysisErrorType.invalidTypeNameInStrictTable, message: 'Invalid type name for a `STRICT` table.', relevantNode: column.typeNames?.toSingleEntity ?? column, )); } } var isGenerated = false; for (final constraint in column.constraints) { isGenerated = isGenerated || constraint is GeneratedAs; if (constraint is PrimaryKeyColumn) { handlePrimaryKeyNode(constraint); } } if (!isGenerated) { hasNonGeneratedColumn = true; } } for (final constraint in e.tableConstraints) { if (constraint is KeyClause && constraint.isPrimaryKey) { handlePrimaryKeyNode(constraint); } } if (e.withoutRowId && !hasPrimaryKeyDeclaration) { context.reportError( AnalysisError( type: AnalysisErrorType.missingPrimaryKey, message: 'Missing PRIMARY KEY declaration for a table without rowid.', relevantNode: e.tableNameToken ?? e, ), ); } if (!hasNonGeneratedColumn) { context.reportError( AnalysisError( type: AnalysisErrorType.allColumnsAreGenerated, message: 'This table is missing a non-generated column', relevantNode: e.tableNameToken ?? e, ), ); } visitChildren(e, arg); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final topLevelBefore = _isTopLevelStatement; _isTopLevelStatement = false; visitChildren(e, arg); _isTopLevelStatement = topLevelBefore; } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { final resolvedColumns = e.query.resolvedColumns; if (e.columns == null || resolvedColumns == null) { return super.visitCreateViewStatement(e, arg); } final amountOfNames = e.columns!.length; final amountOfColumns = resolvedColumns.length; if (amountOfNames != amountOfColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.viewColumnNamesMismatch, relevantNode: e, message: 'This view declares $amountOfNames column names, but the ' 'inner select statement returns $amountOfColumns', )); } visitChildren(e, arg); } @override void visitDefaultValues(DefaultValues e, void arg) { // `DEFAULT VALUES` is not supported in a trigger, see https://www.sqlite.org/lang_insert.html if (!_isTopLevelStatement) { context.reportError( AnalysisError( type: AnalysisErrorType.synctactic, message: '`DEFAULT VALUES` cannot be used in a trigger.', relevantNode: e, ), ); } visitChildren(e, arg); } @override void visitInsertStatement(InsertStatement e, void arg) { for (final target in e.targetColumns) { final resolved = target.resolvedColumn; if (resolved is TableColumn && resolved.isGenerated) { context.reportError( AnalysisError( type: AnalysisErrorType.writeToGeneratedColumn, message: "This column is generated, and generated columns can't " 'be inserted.', relevantNode: target, ), ); } } visitChildren(e, arg); } @override void visitInvocation(SqlInvocation e, void arg) { final lowercaseCall = e.name.toLowerCase(); if (options.addedFunctions.containsKey(lowercaseCall)) { options.addedFunctions[lowercaseCall]!.reportErrors(e, context); } switch (e.name.toLowerCase()) { case 'format': case 'unixepoch': // These were added in sqlite3 version 3.38 if (options.version < SqliteVersion.v3_38) { context.reportError( AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'The `${e.name}` function is not available in ' '${options.version}.', relevantNode: e, ), ); } break; case 'printf': // `printf` was renamed to `format` in sqlite3 version 3.38 if (options.version >= SqliteVersion.v3_38) { context.reportError( AnalysisError( type: AnalysisErrorType.hint, message: '`printf` was renamed to `format()`, consider using ' 'that function instead.', relevantNode: e, ), ); } } visitChildren(e, arg); } @override void visitRaiseExpression(RaiseExpression e, void arg) { if (_isTopLevelStatement) { context.reportError(AnalysisError( type: AnalysisErrorType.raiseMisuse, relevantNode: e, message: 'RAISE can only be used in a trigger.', )); } } @override void visitReturning(Returning e, void arg) { // RETURNING was added in sqlite version 3.35.0 if (context.engineOptions.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, message: 'RETURNING requires sqlite version 3.35 or later', relevantNode: e, )); return; } // https://www.sqlite.org/lang_returning.html#limitations_and_caveats // Returning is not allowed in triggers if (!_isTopLevelStatement) { context.reportError(AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'RETURNING is not allowed in triggers', relevantNode: e, )); } // Returning is not allowed against virtual tables final parent = e.parent; if (parent is HasPrimarySource) { final source = parent.table; if (source is TableReference) { final referenced = source.resultSet?.unalias(); if (referenced is Table && referenced.isVirtual) { context.reportError(AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'RETURNING is not allowed against virtual tables', relevantNode: e, )); } } } for (final column in e.columns) { // Table wildcards are not currently allowed, see // https://www.sqlite.org/src/info/132994c8b1063bfb if (column is StarResultColumn && column.tableName != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Columns in RETURNING may not use the TABLE.* syntax', relevantNode: column, )); } else if (column is ExpressionResultColumn) { // While we're at it, window expressions aren't allowed either if (column.expression is WindowFunctionInvocation) { context.reportError( AnalysisError( type: AnalysisErrorType.illegalUseOfReturning, message: 'Aggregate expressions are not allowed in RETURNING', relevantNode: column.expression, ), ); } } } visitChildren(e, arg); } @override void visitSetComponent(SetComponent e, void arg) { final target = e.column.resolvedColumn; if (target is TableColumn && target.isGenerated) { context.reportError( AnalysisError( type: AnalysisErrorType.writeToGeneratedColumn, message: 'This column is generated, and generated columns cannot be ' 'updated explicitly.', relevantNode: e.column, ), ); } visitChildren(e, arg); } @override void visitTableConstraint(TableConstraint e, void arg) { if (e is KeyClause && e.isPrimaryKey) { // Primary key clauses may only include simple columns for (final column in e.columns) { final expr = column.expression; if (expr is! Reference || expr.entityName != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'Only column names can be used in a PRIMARY KEY clause', relevantNode: expr, )); } } } visitChildren(e, arg); } @override void visitTableReference(TableReference e, void arg) { final parent = e.parent; if (parent is HasPrimarySource && parent.table == e) { // The source of a `INSERT`, `UPDATE` or `DELETE` statement must not have // an alias in `CREATE TRIGGER` statements. if (!_isTopLevelStatement && e.as != null) { context.reportError(AnalysisError( type: AnalysisErrorType.synctactic, message: 'The source must not have an `AS` alias when used in a trigger.', relevantNode: e, )); } } visitChildren(e, arg); } @override void visitTuple(Tuple e, void arg) { if (!e.usedAsRowValue) return; bool isRowValue(Expression? expr) => expr is Tuple || expr is SubQuery; var parent = e.parent; var isAllowed = false; if (parent is WhenComponent && e == parent.when) { // look at the surrounding case expression parent = parent.parent; } if (parent is BinaryExpression) { // Source: https://www.sqlite.org/rowvalue.html#syntax const allowedTokens = [ TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, TokenType.equal, TokenType.doubleEqual, TokenType.lessMore, TokenType.$is, ]; if (allowedTokens.contains(parent.operator.type)) { isAllowed = true; } } else if (parent is BetweenExpression) { // Allowed if all value are row values or subqueries isAllowed = !parent.childNodes.any((e) => !isRowValue(e)); } else if (parent is CaseExpression) { // Allowed if we have something to compare against and all comparisons // are row values if (parent.base == null) { isAllowed = false; } else { final comparisons = [ parent.base, for (final branch in parent.whens) branch.when ]; isAllowed = !comparisons.any((e) => !isRowValue(e)); } } else if (parent is InExpression) { // In expressions are tricky. The rhs can always be a row value, but the // lhs can only be a row value if the rhs is a subquery isAllowed = e == parent.inside || parent.inside is SubQuery; } if (!isAllowed) { context.reportError(AnalysisError( type: AnalysisErrorType.rowValueMisuse, relevantNode: e, message: 'Row values can only be used as expressions in comparisons', )); } } @override void visitUpsertClause(UpsertClause e, void arg) { final hasMultipleClauses = e.entries.length > 1; if (hasMultipleClauses && options.version < SqliteVersion.v3_35) { context.reportError(AnalysisError( type: AnalysisErrorType.notSupportedInDesiredVersion, relevantNode: e, message: 'Multiple on conflict clauses require sqlite version 3.35 or later', )); } visitChildren(e, arg); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { final expectedColumns = e.resolvedColumns!.length; for (final tuple in e.values) { final elementsInTuple = tuple.expressions.length; if (elementsInTuple != expectedColumns) { context.reportError(AnalysisError( type: AnalysisErrorType.valuesSelectCountMismatch, relevantNode: tuple, message: 'The surrounding VALUES clause has $expectedColumns ' 'columns, but this tuple only has $elementsInTuple', )); } } visitChildren(e, arg); } } lib/src/analysis/context.dart 644 0 0 4210 14000111271 14362 0ustar0 pubpubpart of 'analysis.dart'; /// Result of parsing and analyzing an sql statement. Contains the AST with /// resolved references, information about result columns and errors that were /// reported during analysis. class AnalysisContext { /// All errors that occurred during analysis final List errors = []; /// The root node of the abstract syntax tree final AstNode root; /// The raw sql statement that was used to construct this [AnalysisContext]. final String sql; /// Additional information about variables in this context, passed from the /// outside. final AnalyzeStatementOptions stmtOptions; /// Options passed to the surrounding engine. /// /// This contains information about enabled sqlite modules and how to resolve /// some functions. final EngineOptions engineOptions; /// Utilities to read types. final SchemaFromCreateTable schemaSupport; /// New type resolver with better support for nullability and /// complex structures. /// /// By using [TypeInferenceResults.typeOf], the type of an [Expression], /// a [Variable] and [ResultSet.resolvedColumns] may be resolved or inferred. late final TypeInferenceResults types2; /// Constructs a new analysis context from the AST and the source sql. AnalysisContext(this.root, this.sql, this.engineOptions, {AnalyzeStatementOptions? stmtOptions, required this.schemaSupport}) : stmtOptions = stmtOptions ?? const AnalyzeStatementOptions(); /// Reports an analysis error. void reportError(AnalysisError error) { errors.add(error); } /// Obtains the result of any typeable component. See the information at /// [types2] on important [Typeable]s. ResolveResult typeOf(Typeable t) { final type = types2.typeOf(t); return type != null ? ResolveResult(type) : const ResolveResult.unknown(); } /// Compares two [AstNode]s by their first position in the query. static int compareNodesByOrder(AstNode first, AstNode second) { if (first.first == null || second.first == null) { return 0; // position not set. should we throw in that case? } return first.firstPosition.compareTo(second.firstPosition); } } lib/src/ast/statements/insert.dart 644 0 0 6455 14155120333 15364 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart'; // todo: Remove this import enum InsertMode { insert, replace, insertOrReplace, insertOrRollback, insertOrAbort, insertOrFail, insertOrIgnore } class InsertStatement extends CrudStatement implements HasPrimarySource, StatementReturningColumns { final InsertMode mode; @override TableReference table; List targetColumns; InsertSource source; UpsertClause? upsert; @override Returning? returning; @override ResultSet? returnedResultSet; List? get resolvedTargetColumns { if (targetColumns.isNotEmpty) { return targetColumns.map((c) => c.resolvedColumn).toList(); } else { // no columns declared - assume all columns from the table that are not // generated. return table.resultSet?.resolvedColumns ?.where((c) => c is! TableColumn || !c.isGenerated) .toList(); } } InsertStatement({ WithClause? withClause, this.mode = InsertMode.insert, required this.table, required this.targetColumns, required this.source, this.upsert, this.returning, }) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInsertStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); table = transformer.transformChild(table, this, arg); targetColumns = transformer.transformChildren(targetColumns, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, table, ...targetColumns, source, if (upsert != null) upsert!, if (returning != null) returning!, ]; } /// Marker interface for AST nodes that can be used as data sources in insert /// statements. abstract class InsertSource extends AstNode {} /// Uses a list of values for an insert statement (`VALUES (a, b, c)`). class ValuesSource extends InsertSource { List values; ValuesSource(this.values); @override Iterable get childNodes => values; @override R accept(AstVisitor visitor, A arg) { return visitor.visitValuesSource(this, arg); } @override void transformChildren(Transformer transformer, A arg) { values = transformer.transformChildren(values, this, arg); } } /// Inserts the rows returned by [stmt]. class SelectInsertSource extends InsertSource { BaseSelectStatement stmt; SelectInsertSource(this.stmt); @override Iterable get childNodes => [stmt]; @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectInsertSource(this, arg); } @override void transformChildren(Transformer transformer, A arg) { stmt = transformer.transformChild(stmt, this, arg); } } /// Use `DEFAULT VALUES` for an insert statement. class DefaultValues extends InsertSource { @override Iterable get childNodes => const []; @override R accept(AstVisitor visitor, A arg) { return visitor.visitDefaultValues(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/statements/block.dart 644 0 0 1152 14047764625 15161 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../visitor.dart'; import 'statement.dart'; /// BLOCK = 'BEGIN' < CRUD-STATEMENT ';' > 'END' class Block extends AstNode { Token? begin; Token? end; List statements; Block(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBlock(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statements = transformer.transformChildren(statements, this, arg); } @override Iterable get childNodes => statements; } lib/src/ast/statements/create_view.dart 644 0 0 2376 14206506214 16356 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import /// A "CREATE VIEW" statement, see https://sqlite.org/lang_createview.html class CreateViewStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String viewName; IdentifierToken? viewNameToken; BaseSelectStatement query; final List? columns; /// Drift-specific information about the desired name of a Dart class for this /// table. /// /// This will always be `null` when drift extensions are not enabled. DriftTableName? driftTableName; CreateViewStatement({ this.ifNotExists = false, required this.viewName, this.columns, required this.query, this.driftTableName, }); @override String get createdName => viewName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateViewStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { query = transformer.transformChild(query, this, arg); driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [query, if (driftTableName != null) driftTableName!]; } lib/src/ast/statements/create_index.dart 644 0 0 3720 14155120333 16502 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import class CreateIndexStatement extends Statement implements CreatingStatement, StatementWithWhere { final String indexName; final bool unique; final bool ifNotExists; IdentifierToken? nameToken; TableReference on; List columns; @override Expression? where; CreateIndexStatement( {required this.indexName, this.unique = false, this.ifNotExists = false, required this.on, required this.columns, this.where}); @override String get createdName => indexName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateIndexStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { on = transformer.transformChild(on, this, arg); columns = transformer.transformChildren(columns, this, arg); where = transformer.transformNullableChild(where, this, arg); } @override Iterable get childNodes => [on, ...columns, if (where != null) where!]; } /// Note that this class matches the productions listed at https://www.sqlite.org/syntax/indexed-column.html /// We don't have a special case for `column-name` (those are [Reference]s). /// The `COLLATE` branch is covered by parsing a [CollateExpression] for /// [expression]. class IndexedColumn extends AstNode { /// The expression on which the index should be created. Most commonly a /// [Reference], for simple column names. Expression expression; final OrderingMode? ordering; IndexedColumn(this.expression, [this.ordering]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIndexedColumn(this, arg); } @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } lib/src/ast/statements/update.dart 644 0 0 4756 14155120333 15344 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import enum FailureMode { rollback, abort, replace, fail, ignore, } const Map _tokensToMode = { TokenType.rollback: FailureMode.rollback, TokenType.abort: FailureMode.abort, TokenType.replace: FailureMode.replace, TokenType.fail: FailureMode.fail, TokenType.ignore: FailureMode.ignore, }; class UpdateStatement extends CrudStatement implements StatementWithWhere, HasPrimarySource, HasFrom, StatementReturningColumns { final FailureMode? or; @override TableReference table; List set; @override Queryable? from; @override Expression? where; @override Returning? returning; @override ResultSet? returnedResultSet; UpdateStatement({ WithClause? withClause, this.or, required this.table, required this.set, this.from, this.where, this.returning, }) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpdateStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); table = transformer.transformChild(table, this, arg); set = transformer.transformChildren(set, this, arg); from = transformer.transformNullableChild(from, this, arg); where = transformer.transformChild(where!, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, table, ...set, if (from != null) from!, if (where != null) where!, if (returning != null) returning!, ]; static FailureMode? failureModeFromToken(TokenType token) { return _tokensToMode[token]; } } class SetComponent extends AstNode { Reference column; Expression expression; SetComponent({required this.column, required this.expression}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSetComponent(this, arg); } @override void transformChildren(Transformer transformer, A arg) { column = transformer.transformChild(column, this, arg); expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [column, expression]; } lib/src/ast/statements/transaction.dart 644 0 0 1754 14131303604 16400 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../visitor.dart'; import 'statement.dart'; enum TransactionMode { none, deferred, immediate, exclusive } class BeginTransactionStatement extends Statement { Token? begin, modeToken, transaction; final TransactionMode mode; BeginTransactionStatement([this.mode = TransactionMode.none]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBeginTransaction(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } class CommitStatement extends Statement { Token? commitOrEnd, transaction; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCommitStatement(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/statements/create_table.dart 644 0 0 6556 14206506254 16503 0ustar0 pubpubimport 'package:source_span/source_span.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class TableInducingStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String tableName; /// Drift-specific information about the desired name of a Dart class for this /// table. /// /// This will always be `null` when drift extensions are not enabled. DriftTableName? driftTableName; Token? tableNameToken; TableInducingStatement._(this.ifNotExists, this.tableName, [this.driftTableName]); @override String get createdName => tableName; } /// A "CREATE TABLE" statement, see https://www.sqlite.org/lang_createtable.html /// for the individual components. class CreateTableStatement extends TableInducingStatement { List columns; List tableConstraints; /// Whether this table has been defined with an `WITHOUT ROWID` clause. final bool withoutRowId; /// Whether this table has been defined as `STRICT`. /// /// Strict tables are limited to a few column type names. Columns in strict /// tables may not store other types. final bool isStrict; Token? openingBracket; Token? closingBracket; Token? strict; CreateTableStatement({ bool ifNotExists = false, required String tableName, this.columns = const [], this.tableConstraints = const [], this.withoutRowId = false, this.isStrict = false, DriftTableName? driftTableName, }) : super._(ifNotExists, tableName, driftTableName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateTableStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); tableConstraints = transformer.transformChildren(tableConstraints, this, arg); driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [ ...columns, ...tableConstraints, if (driftTableName != null) driftTableName!, ]; } class CreateVirtualTableStatement extends TableInducingStatement { /// The module that will be invoked when creating the virtual table. final String moduleName; Token? moduleNameToken; /// Arguments passed to the module. Since the specific module is responsible /// for parsing them, the general parser only exposes them as strings with a /// source location. final List arguments; List? _argumentText; List get argumentContent { return _argumentText ??= arguments.map((a) => a.text).toList(); } CreateVirtualTableStatement({ bool ifNotExists = false, required String tableName, required this.moduleName, this.arguments = const [], DriftTableName? driftTableName, }) : super._(ifNotExists, tableName, driftTableName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateVirtualTableStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { driftTableName = transformer.transformNullableChild(driftTableName, this, arg); } @override Iterable get childNodes => [if (driftTableName != null) driftTableName!]; } lib/src/ast/statements/statement.dart 644 0 0 4341 14206505250 16056 0ustar0 pubpubimport 'package:meta/meta.dart'; import '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class Statement extends AstNode { Token? semicolon; } /// A statement that reads from an existing table structure and has an optional /// `WITH` clause. abstract class CrudStatement extends Statement { WithClause? withClause; @internal CrudStatement(this.withClause); } /// Interfaces for statements that have a primary source table on which they /// operate. /// This includes delete, update and insert statements. It also includes the /// common [SelectStatement], but not compound select statements or `VALUES` /// statements. abstract class HasPrimarySource extends Statement { /// The primary table this statement operates on. This is the part after the /// `FROM` for select and delete statements, the part after the `INTO` for /// inserts and the name after the `UPDATE` for updates. Queryable? get table; } /// Interfaces for statements that have a `FROM` clause. /// /// This includes selects and, since recently, updates. abstract class HasFrom extends Statement { /// The table, join clause or subquery appearing in the `FROM` clause. Queryable? get from; } /// Interface for statements that have a primary where clause (select, update, /// delete). abstract class StatementWithWhere extends Statement implements HasWhereClause {} /// Interface for statements that can return columns after writing data. /// /// Columns are returned with a `RETURNING` clause (see [Returning]). After /// analyzing a node, statements with a [returning] clause will have their /// [returnedResultSet] set to the resolved columns. abstract class StatementReturningColumns extends Statement { /// The returning clause of this statement, if there is any. Returning? get returning; /// The result set of the [returning] clause. ResultSet? returnedResultSet; } /// Marker interface for statements that change the table structure. abstract class SchemaStatement extends Statement implements PartOfDriftFile {} /// Marker interface for schema statements that create a schematic entity. abstract class CreatingStatement extends SchemaStatement { String get createdName; } lib/src/ast/statements/delete.dart 644 0 0 2264 14155120333 15314 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart'; // todo: Remove this import class DeleteStatement extends CrudStatement implements StatementWithWhere, StatementReturningColumns, HasPrimarySource { TableReference from; @override Expression? where; @override TableReference get table => from; @override Returning? returning; @override ResultSet? returnedResultSet; DeleteStatement( {WithClause? withClause, required this.from, this.where, this.returning}) : super(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeleteStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); from = transformer.transformChild(from, this, arg); where = transformer.transformNullableChild(where, this, arg); returning = transformer.transformNullableChild(returning, this, arg); } @override Iterable get childNodes => [ if (withClause != null) withClause!, from, if (where != null) where!, if (returning != null) returning!, ]; } lib/src/ast/statements/create_trigger.dart 644 0 0 6256 14155120333 17045 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import /// A "CREATE TRIGGER" statement, see https://sqlite.org/lang_createtrigger.html class CreateTriggerStatement extends Statement implements CreatingStatement { final bool ifNotExists; final String triggerName; IdentifierToken? triggerNameToken; final TriggerMode mode; TriggerTarget target; TableReference onTable; Expression? when; Block action; CreateTriggerStatement( {this.ifNotExists = false, required this.triggerName, required this.mode, required this.target, required this.onTable, this.when, required this.action}); @override String get createdName => triggerName; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCreateTriggerStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { onTable = transformer.transformChild(onTable, this, arg); when = transformer.transformNullableChild(when, this, arg); action = transformer.transformChild(action, this, arg); target = transformer.transformChild(target, this, arg); } @override Iterable get childNodes => [ target, onTable, if (when != null) when!, action, ]; } enum TriggerMode { before, after, insteadOf } abstract class TriggerTarget extends AstNode { @override int get hashCode => runtimeType.hashCode; @override bool operator ==(dynamic other) => other.runtimeType == runtimeType; @override Iterable get childNodes => const Iterable.empty(); /// Whether this target introduces the "new" table reference in the sub-scope /// of the create trigger statement. bool get introducesNew; /// Whether this target introduces the "old" table reference in the sub-scope /// of the create trigger statement. bool get introducesOld; } class DeleteTarget extends TriggerTarget { Token? deleteToken; @override bool get introducesNew => false; @override bool get introducesOld => true; @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeleteTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } class InsertTarget extends TriggerTarget { Token? insertToken; @override bool get introducesNew => true; @override bool get introducesOld => false; @override R accept(AstVisitor visitor, A arg) { return visitor.visitInsertTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} } class UpdateTarget extends TriggerTarget { Token? updateToken; List columnNames; UpdateTarget(this.columnNames); @override bool get introducesNew => true; @override bool get introducesOld => true; @override Iterable get childNodes => columnNames; @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpdateTriggerTarget(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columnNames = transformer.transformChildren(columnNames, this, arg); } } lib/src/ast/statements/select.dart 644 0 0 15017 14155120333 15351 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../../reader/tokenizer/token.dart'; import '../ast.dart'; // todo: Remove this import abstract class BaseSelectStatement extends CrudStatement with ResultSet { /// The resolved list of columns returned by this select statements. Not /// available from the parse tree, will be set later by the analyzer. @override List? resolvedColumns; BaseSelectStatement._(WithClause? withClause) : super(withClause); } /// Marker interface for classes that are a [BaseSelectStatement] but aren't a /// [CompoundSelectStatement]. abstract class SelectStatementNoCompound implements BaseSelectStatement {} class SelectStatement extends BaseSelectStatement implements StatementWithWhere, SelectStatementNoCompound, HasPrimarySource, HasFrom { final bool distinct; List columns; @override Queryable? from; @override Expression? where; GroupBy? groupBy; final List windowDeclarations; OrderByBase? orderBy; LimitBase? limit; @override Queryable? get table => from; SelectStatement( {WithClause? withClause, this.distinct = false, required this.columns, this.from, this.where, this.groupBy, this.windowDeclarations = const [], this.orderBy, this.limit}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); columns = transformer.transformChildren(columns, this, arg); from = transformer.transformNullableChild(from, this, arg); where = transformer.transformNullableChild(where, this, arg); groupBy = transformer.transformNullableChild(groupBy, this, arg); // transformer.transformChildren(windowDeclarations, this, arg); limit = transformer.transformNullableChild(limit, this, arg); orderBy = transformer.transformNullableChild(orderBy, this, arg); } @override Iterable get childNodes { return [ if (withClause != null) withClause!, ...columns, if (from != null) from!, if (where != null) where!, if (groupBy != null) groupBy!, for (var windowDecl in windowDeclarations) windowDecl.definition, if (limit != null) limit!, if (orderBy != null) orderBy!, ]; } } class CompoundSelectStatement extends BaseSelectStatement { SelectStatementNoCompound base; List additional; // the grammar under https://www.sqlite.org/syntax/compound-select-stmt.html // defines an order by and limit clause on this node, but we parse them as // part of the last compound select statement in [additional] CompoundSelectStatement({ WithClause? withClause, required this.base, this.additional = const [], }) : super._(withClause); @override Iterable get childNodes { return [if (withClause != null) withClause!, base, ...additional]; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitCompoundSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { withClause = transformer.transformNullableChild(withClause, this, arg); base = transformer.transformChild(base, this, arg); additional = transformer.transformChildren(additional, this, arg); } } /// A select statement of the form `VALUES (expr-list), ..., (expr-list-N)`. class ValuesSelectStatement extends BaseSelectStatement implements SelectStatementNoCompound { List values; ValuesSelectStatement(this.values, {WithClause? withClause}) : super._(withClause); @override R accept(AstVisitor visitor, A arg) { return visitor.visitValuesSelectStatement(this, arg); } @override void transformChildren(Transformer transformer, A arg) { values = transformer.transformChildren(values, this, arg); } @override Iterable get childNodes => values; } abstract class ResultColumn extends AstNode {} /// A result column that either yields all columns or all columns from a table /// by using "*" or "table.*". class StarResultColumn extends ResultColumn { final String? tableName; StarResultColumn([this.tableName]); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitStarResultColumn(this, arg); } } class ExpressionResultColumn extends ResultColumn implements Renamable, Referencable { Expression expression; @override final String? as; ExpressionResultColumn({required this.expression, this.as}); @override bool get visibleToChildren => false; @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override R accept(AstVisitor visitor, A arg) { return visitor.visitExpressionResultColumn(this, arg); } } class GroupBy extends AstNode { /// The list of expressions that form the partition List by; Expression? having; GroupBy({required this.by, this.having}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitGroupBy(this, arg); } @override void transformChildren(Transformer transformer, A arg) { by = transformer.transformChildren(by, this, arg); having = transformer.transformNullableChild(having, this, arg); } @override Iterable get childNodes => [...by, if (having != null) having!]; } enum CompoundSelectMode { union, unionAll, intersect, except, } class CompoundSelectPart extends AstNode { final CompoundSelectMode mode; SelectStatementNoCompound select; /// The first token of this statement, so either union, intersect or except. Token? firstModeToken; /// The "ALL" token, if this is a "UNION ALL" part Token? allToken; CompoundSelectPart({required this.mode, required this.select}); @override Iterable get childNodes => [select]; @override R accept(AstVisitor visitor, A arg) { return visitor.visitCompoundSelectPart(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } } lib/src/ast/statements/invalid.dart 644 0 0 647 14025064205 15464 0ustar0 pubpubimport '../ast.dart'; /// Used as a top-level substitute when no statement could be parsed otherwise. class InvalidStatement extends Statement { @override R accept(AstVisitor visitor, A arg) { return visitor.visitInvalidStatement(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/clauses/ordering.dart 644 0 0 3217 14206506164 15141 0ustar0 pubpubpart of '../ast.dart'; /// Base for `ORDER BY` clauses. Without drift extensions, ony [OrderBy] will be /// parsed. Otherwise, [DartOrderByPlaceholder] can be parsed as well. abstract class OrderByBase extends AstNode {} /// Base for a single ordering term that is a part of a [OrderBy]. Without drift /// extensions, only [OrderingTerm] will be parsed. With drift extensions, a /// [DartOrderingTermPlaceholder] can be parsed as well. abstract class OrderingTermBase extends AstNode {} class OrderBy extends AstNode implements OrderByBase { List terms; OrderBy({this.terms = const []}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderBy(this, arg); } @override void transformChildren(Transformer transformer, A arg) { terms = transformer.transformChildren(terms, this, arg); } @override Iterable get childNodes => terms; } enum OrderingMode { ascending, descending } enum OrderingBehaviorForNulls { first, last } class OrderingTerm extends AstNode implements OrderingTermBase { Expression expression; OrderingMode? orderingMode; OrderingBehaviorForNulls? nulls; OrderingMode get resolvedOrderingMode => orderingMode ?? OrderingMode.ascending; OrderingTerm({required this.expression, this.orderingMode, this.nulls}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitOrderingTerm(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } lib/src/ast/clauses/upsert.dart 644 0 0 4300 14155120333 14635 0ustar0 pubpubimport '../ast.dart'; // todo: Remove this import class UpsertClause extends AstNode { List entries; UpsertClause(this.entries); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpsertClause(this, arg); } @override List get childNodes => entries; @override void transformChildren(Transformer transformer, A arg) { entries = transformer.transformChildren(entries, this, arg); } } class UpsertClauseEntry extends AstNode implements HasWhereClause { List? onColumns; @override Expression? where; UpsertAction action; UpsertClauseEntry({this.onColumns, this.where, required this.action}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUpsertClauseEntry(this, arg); } @override void transformChildren(Transformer transformer, A arg) { if (onColumns != null) { onColumns = transformer.transformChildren(onColumns!, this, arg); } where = transformer.transformNullableChild(where, this, arg); action = transformer.transformChild(action, this, arg); } @override Iterable get childNodes { return [ if (onColumns != null) ...onColumns!, if (where != null) where!, action, ]; } } abstract class UpsertAction extends AstNode {} class DoNothing extends UpsertAction { @override R accept(AstVisitor visitor, A arg) { return visitor.visitDoNothing(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; } class DoUpdate extends UpsertAction implements HasWhereClause { List set; @override Expression? where; DoUpdate(this.set, {this.where}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDoUpdate(this, arg); } @override void transformChildren(Transformer transformer, A arg) { set = transformer.transformChildren(set, this, arg); where = transformer.transformNullableChild(where, this, arg); } @override Iterable get childNodes => [...set, if (where != null) where!]; } lib/src/ast/clauses/with.dart 644 0 0 5016 14047764625 14315 0ustar0 pubpubpart of '../ast.dart'; class WithClause extends AstNode { Token? withToken; final bool recursive; Token? recursiveToken; List ctes; WithClause({required this.recursive, required this.ctes}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWithClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { ctes = transformer.transformChildren(ctes, this, arg); } @override Iterable get childNodes => ctes; } enum MaterializationHint { materialized, notMaterialized, } class CommonTableExpression extends AstNode with ResultSet { final String cteTableName; final MaterializationHint? materializationHint; /// The `not` token before the `materialized` token, if there is any. Token? not; /// The `materialized` token, if there is any. Token? materialized; /// If this common table expression has explicit column names, e.g. with /// `cnt(x) AS (...)`, contains the column names (`['x']`, in that case). /// Otherwise null. final List? columnNames; BaseSelectStatement as; Token? asToken; IdentifierToken? tableNameToken; List? _cachedColumns; CommonTableExpression({ required this.cteTableName, this.materializationHint, this.columnNames, required this.as, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCommonTableExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { as = transformer.transformChild(as, this, arg); } @override Iterable get childNodes => [as]; @override List? get resolvedColumns { final columnsOfSelect = as.resolvedColumns; // we don't override column names, so just return the columns declared by // the select statement if (columnNames == null) return columnsOfSelect; final cached = _cachedColumns ??= columnNames! .map((name) => CommonTableExpressionColumn(name)..containingSet = this) .toList(); if (columnsOfSelect != null) { // bind the CommonTableExpressionColumn to the real underlying column // returned by the select statement for (var i = 0; i < cached.length; i++) { if (i < columnsOfSelect.length) { final selectColumn = columnsOfSelect[i]; cached[i].innerColumn = selectColumn; } } } return _cachedColumns; } @override bool get visibleToChildren => true; } lib/src/ast/clauses/limit.dart 644 0 0 2073 14206506123 14440 0ustar0 pubpubpart of '../ast.dart'; /// Base for `LIMIT` clauses. Without drift extensions, only [Limit] will be /// parsed. With drift extensions, a [DartLimitPlaceholder] can be emitted as /// well. abstract class LimitBase implements AstNode {} class Limit extends AstNode implements LimitBase { Expression count; Token? offsetSeparator; // can either be OFFSET or just a comma Expression? offset; Limit({required this.count, this.offsetSeparator, this.offset}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitLimit(this, arg); } @override void transformChildren(Transformer transformer, A arg) { count = transformer.transformChild(count, this, arg); offset = transformer.transformNullableChild(offset, this, arg); } @override Iterable get childNodes { if (offsetSeparator?.type == TokenType.offset) { // Amount first, then offset return [count, offset!]; } // If using a comma, the count is followed by an optional offset return [count, if (offset != null) offset!]; } } lib/src/ast/clauses/returning.dart 644 0 0 1354 14047764625 15360 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../statements/select.dart' show ResultColumn; import '../visitor.dart'; /// A returning clause describes expressions to evaluate after an insert, an /// update or a delete statement. class Returning extends AstNode { /// The `RETURNING` token as found in the source. Token? returning; List columns; Returning(this.columns); @override List get childNodes => columns; @override R accept(AstVisitor visitor, A arg) { return visitor.visitReturning(this, arg); } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); } } lib/src/ast/visitor.dart 644 0 0 40134 14211620563 13403 0ustar0 pubpubimport 'ast.dart'; abstract class AstVisitor { R visitSelectStatement(SelectStatement e, A arg); R visitCompoundSelectStatement(CompoundSelectStatement e, A arg); R visitCompoundSelectPart(CompoundSelectPart e, A arg); R visitValuesSelectStatement(ValuesSelectStatement e, A arg); R visitInsertStatement(InsertStatement e, A arg); R visitDeleteStatement(DeleteStatement e, A arg); R visitUpdateStatement(UpdateStatement e, A arg); R visitCreateTableStatement(CreateTableStatement e, A arg); R visitCreateVirtualTableStatement(CreateVirtualTableStatement e, A arg); R visitCreateTriggerStatement(CreateTriggerStatement e, A arg); R visitCreateIndexStatement(CreateIndexStatement e, A arg); R visitCreateViewStatement(CreateViewStatement e, A arg); R visitInvalidStatement(InvalidStatement e, A arg); R visitReturning(Returning e, A arg); R visitWithClause(WithClause e, A arg); R visitUpsertClause(UpsertClause e, A arg); R visitUpsertClauseEntry(UpsertClauseEntry e, A arg); R visitCommonTableExpression(CommonTableExpression e, A arg); R visitOrderBy(OrderBy e, A arg); R visitOrderingTerm(OrderingTerm e, A arg); R visitLimit(Limit e, A arg); R visitStarResultColumn(StarResultColumn e, A arg); R visitExpressionResultColumn(ExpressionResultColumn e, A arg); R visitTableReference(TableReference e, A arg); R visitSelectStatementAsSource(SelectStatementAsSource e, A arg); R visitJoinClause(JoinClause e, A arg); R visitTableValuedFunction(TableValuedFunction e, A arg); R visitJoin(Join e, A arg); R visitGroupBy(GroupBy e, A arg); R visitDeleteTriggerTarget(DeleteTarget e, A arg); R visitInsertTriggerTarget(InsertTarget e, A arg); R visitUpdateTriggerTarget(UpdateTarget e, A arg); R visitDoNothing(DoNothing e, A arg); R visitDoUpdate(DoUpdate e, A arg); R visitSetComponent(SetComponent e, A arg); R visitValuesSource(ValuesSource e, A arg); R visitSelectInsertSource(SelectInsertSource e, A arg); R visitDefaultValues(DefaultValues e, A arg); R visitColumnDefinition(ColumnDefinition e, A arg); R visitColumnConstraint(ColumnConstraint e, A arg); R visitTableConstraint(TableConstraint e, A arg); R visitForeignKeyClause(ForeignKeyClause e, A arg); R visitDeferrableClause(DeferrableClause e, A arg); R visitNumericLiteral(NumericLiteral e, A arg); R visitNullLiteral(NullLiteral e, A arg); R visitBooleanLiteral(BooleanLiteral e, A arg); R visitStringLiteral(StringLiteral e, A arg); R visitTimeConstantLiteral(TimeConstantLiteral e, A arg); R visitCastExpression(CastExpression e, A arg); R visitBinaryExpression(BinaryExpression e, A arg); R visitStringComparison(StringComparisonExpression e, A arg); R visitCollateExpression(CollateExpression e, A arg); R visitUnaryExpression(UnaryExpression e, A arg); R visitIsExpression(IsExpression e, A arg); R visitIsNullExpression(IsNullExpression e, A arg); R visitBetweenExpression(BetweenExpression e, A arg); R visitReference(Reference e, A arg); R visitFunction(FunctionExpression e, A arg); R visitStarFunctionParameter(StarFunctionParameter e, A arg); R visitExpressionFunctionParameters(ExprFunctionParameters e, A arg); R visitSubQuery(SubQuery e, A arg); R visitExists(ExistsExpression e, A arg); R visitCaseExpression(CaseExpression e, A arg); R visitWhen(WhenComponent e, A arg); R visitTuple(Tuple e, A arg); R visitParentheses(Parentheses e, A arg); R visitInExpression(InExpression e, A arg); R visitRaiseExpression(RaiseExpression e, A arg); R visitAggregateFunctionInvocation(AggregateFunctionInvocation e, A arg); R visitWindowFunctionInvocation(WindowFunctionInvocation e, A arg); R visitWindowDefinition(WindowDefinition e, A arg); R visitFrameSpec(FrameSpec e, A arg); R visitIndexedColumn(IndexedColumn e, A arg); R visitNumberedVariable(NumberedVariable e, A arg); R visitNamedVariable(ColonNamedVariable e, A arg); R visitBlock(Block block, A arg); R visitBeginTransaction(BeginTransactionStatement e, A arg); R visitCommitStatement(CommitStatement e, A arg); R visitDriftSpecificNode(DriftSpecificNode e, A arg); } /// Visitor that walks down the entire tree, visiting all children in order. class RecursiveVisitor implements AstVisitor { // Statements @override R? visitInvalidStatement(InvalidStatement e, A arg) { return visitStatement(e, arg); } @override R? visitSelectStatement(SelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitValuesSelectStatement(ValuesSelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitCompoundSelectStatement(CompoundSelectStatement e, A arg) { return visitBaseSelectStatement(e, arg); } @override R? visitInsertStatement(InsertStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitDeleteStatement(DeleteStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitUpdateStatement(UpdateStatement e, A arg) { return visitCrudStatement(e, arg); } @override R? visitCreateTableStatement(CreateTableStatement e, A arg) { return visitTableInducingStatement(e, arg); } @override R? visitCreateVirtualTableStatement(CreateVirtualTableStatement e, A arg) { return visitTableInducingStatement(e, arg); } @override R? visitCreateViewStatement(CreateViewStatement e, A arg) { return visitSchemaStatement(e, arg); } @override R? visitCreateTriggerStatement(CreateTriggerStatement e, A arg) { return visitSchemaStatement(e, arg); } @override R? visitCreateIndexStatement(CreateIndexStatement e, A arg) { return visitSchemaStatement(e, arg); } R? visitBaseSelectStatement(BaseSelectStatement stmt, A arg) { return visitCrudStatement(stmt, arg); } R? visitCrudStatement(CrudStatement stmt, A arg) { return visitStatement(stmt, arg); } R? visitTableInducingStatement(TableInducingStatement stmt, A arg) { return visitSchemaStatement(stmt, arg); } R? visitSchemaStatement(SchemaStatement stmt, A arg) { return visitStatement(stmt, arg); } R? visitStatement(Statement statement, A arg) { return defaultNode(statement, arg); } @override R? visitCompoundSelectPart(CompoundSelectPart e, A arg) { return defaultNode(e, arg); } // General clauses R? visitResultColumn(ResultColumn e, A arg) { return defaultNode(e, arg); } @override R? visitStarResultColumn(StarResultColumn e, A arg) { return visitResultColumn(e, arg); } @override R? visitExpressionResultColumn(ExpressionResultColumn e, A arg) { return visitResultColumn(e, arg); } @override R? visitReturning(Returning e, A arg) { return defaultNode(e, arg); } @override R? visitWithClause(WithClause e, A arg) { return defaultNode(e, arg); } @override R? visitUpsertClause(UpsertClause e, A arg) { return defaultNode(e, arg); } @override R? visitUpsertClauseEntry(UpsertClauseEntry e, A arg) { return defaultNode(e, arg); } @override R? visitDeleteTriggerTarget(DeleteTarget e, A arg) { return defaultTriggerTarget(e, arg); } @override R? visitInsertTriggerTarget(InsertTarget e, A arg) { return defaultTriggerTarget(e, arg); } @override R? visitUpdateTriggerTarget(UpdateTarget e, A arg) { return defaultTriggerTarget(e, arg); } R? defaultTriggerTarget(TriggerTarget e, A arg) { return defaultNode(e, arg); } @override R? visitDoNothing(DoNothing e, A arg) { return defaultUpsertAction(e, arg); } @override R? visitDoUpdate(DoUpdate e, A arg) { return defaultUpsertAction(e, arg); } R? defaultUpsertAction(UpsertAction e, A arg) { return defaultNode(e, arg); } @override R? visitCommonTableExpression(CommonTableExpression e, A arg) { return defaultNode(e, arg); } @override R? visitOrderBy(OrderBy e, A arg) { return defaultNode(e, arg); } @override R? visitOrderingTerm(OrderingTerm e, A arg) { return defaultNode(e, arg); } @override R? visitLimit(Limit e, A arg) { return defaultNode(e, arg); } @override R? visitTableReference(TableReference e, A arg) { return defaultQueryable(e, arg); } @override R? visitSelectStatementAsSource(SelectStatementAsSource e, A arg) { return defaultQueryable(e, arg); } @override R? visitJoinClause(JoinClause e, A arg) { return defaultQueryable(e, arg); } @override R? visitTableValuedFunction(TableValuedFunction e, A arg) { return defaultQueryable(e, arg); } R? defaultQueryable(Queryable e, A arg) { return defaultNode(e, arg); } @override R? visitJoin(Join e, A arg) { return defaultNode(e, arg); } @override R? visitGroupBy(GroupBy e, A arg) { return defaultNode(e, arg); } @override R? visitSetComponent(SetComponent e, A arg) { return defaultNode(e, arg); } @override R? visitValuesSource(ValuesSource e, A arg) { return defaultInsertSource(e, arg); } @override R? visitSelectInsertSource(SelectInsertSource e, A arg) { return defaultInsertSource(e, arg); } @override R? visitDefaultValues(DefaultValues e, A arg) { return defaultInsertSource(e, arg); } R? defaultInsertSource(InsertSource e, A arg) { return defaultNode(e, arg); } @override R? visitColumnDefinition(ColumnDefinition e, A arg) { return defaultNode(e, arg); } @override R? visitColumnConstraint(ColumnConstraint e, A arg) { return defaultNode(e, arg); } @override R? visitTableConstraint(TableConstraint e, A arg) { return defaultNode(e, arg); } @override R? visitForeignKeyClause(ForeignKeyClause e, A arg) { return defaultNode(e, arg); } @override R? visitDeferrableClause(DeferrableClause e, A arg) { return defaultNode(e, arg); } @override R? visitWindowDefinition(WindowDefinition e, A arg) { return defaultNode(e, arg); } @override R? visitFrameSpec(FrameSpec e, A arg) { return defaultNode(e, arg); } @override R? visitIndexedColumn(IndexedColumn e, A arg) { return defaultNode(e, arg); } @override R? visitBlock(Block e, A arg) { return defaultNode(e, arg); } @override R? visitBeginTransaction(BeginTransactionStatement e, A arg) { return visitStatement(e, arg); } @override R? visitCommitStatement(CommitStatement e, A arg) { return visitStatement(e, arg); } @override R? visitDriftSpecificNode(DriftSpecificNode e, A arg) { return defaultNode(e, arg); } // Expressions @override R? visitCastExpression(CastExpression e, A arg) { return visitExpression(e, arg); } @override R? visitBinaryExpression(BinaryExpression e, A arg) { return visitExpression(e, arg); } @override R? visitCollateExpression(CollateExpression e, A arg) { return visitUnaryExpression(e, arg); } @override R? visitUnaryExpression(UnaryExpression e, A arg) { return visitExpression(e, arg); } @override R? visitStringComparison(StringComparisonExpression e, A arg) { return visitExpression(e, arg); } @override R? visitIsExpression(IsExpression e, A arg) { return visitExpression(e, arg); } @override R? visitIsNullExpression(IsNullExpression e, A arg) { return visitExpression(e, arg); } @override R? visitBetweenExpression(BetweenExpression e, A arg) { return visitExpression(e, arg); } R? defaultLiteral(Literal e, A arg) { return visitExpression(e, arg); } @override R? visitNullLiteral(NullLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitNumericLiteral(Literal e, A arg) { return defaultLiteral(e, arg); } @override R? visitBooleanLiteral(BooleanLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitStringLiteral(StringLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitTimeConstantLiteral(TimeConstantLiteral e, A arg) { return defaultLiteral(e, arg); } @override R? visitReference(Reference e, A arg) { return visitExpression(e, arg); } @override R? visitFunction(FunctionExpression e, A arg) { return visitExpressionInvocation(e, arg); } R? visitFunctionParameters(FunctionParameters e, A arg) { return defaultNode(e, arg); } @override R? visitStarFunctionParameter(StarFunctionParameter e, A arg) { return visitFunctionParameters(e, arg); } @override R? visitExpressionFunctionParameters(ExprFunctionParameters e, A arg) { return visitFunctionParameters(e, arg); } @override R? visitAggregateFunctionInvocation(AggregateFunctionInvocation e, A arg) { return visitExpressionInvocation(e, arg); } @override R? visitWindowFunctionInvocation(WindowFunctionInvocation e, A arg) { return visitExpressionInvocation(e, arg); } @override R? visitSubQuery(SubQuery e, A arg) { return visitExpression(e, arg); } @override R? visitExists(ExistsExpression e, A arg) { return visitExpression(e, arg); } @override R? visitCaseExpression(CaseExpression e, A arg) { return visitExpression(e, arg); } @override R? visitWhen(WhenComponent e, A arg) { return defaultNode(e, arg); } @override R? visitTuple(Tuple e, A arg) { return visitExpression(e, arg); } @override R? visitParentheses(Parentheses e, A arg) { return visitExpression(e, arg); } @override R? visitInExpression(InExpression e, A arg) { return visitExpression(e, arg); } @override R? visitRaiseExpression(RaiseExpression e, A arg) { return visitExpression(e, arg); } @override R? visitNumberedVariable(NumberedVariable e, A arg) { return visitVariable(e, arg); } @override R? visitNamedVariable(ColonNamedVariable e, A arg) { return visitVariable(e, arg); } R? visitVariable(Variable e, A arg) { return visitExpression(e, arg); } R? visitExpressionInvocation(ExpressionInvocation e, A arg) { return visitInvocation(e, arg); } R? visitInvocation(SqlInvocation e, A arg) { return defaultNode(e, arg); } R? visitExpression(Expression e, A arg) { return defaultNode(e, arg); } R? defaultNode(AstNode e, A arg) { return visitChildren(e, arg); } } class Transformer extends RecursiveVisitor { @override AstNode defaultNode(AstNode e, A arg) => e..transformChildren(this, arg); } extension VisitExtension on AstVisitor { /// Visits the node [e] by calling [AstNode.accept]. R visit(AstNode e, A arg) => e.accept(this, arg); /// Visits the node [e] if it's not null. Otherwise, do nothing. R? visitNullable(AstNode? e, A arg) => e?.accept(this, arg); } extension VisitChildrenExtension on AstVisitor { /// Visits all children of the node [e], in the order of [AstNode.childNodes]. R? visitChildren(AstNode e, A arg) { return visitList(e.childNodes, arg); } /// Visits all [nodes] in sequence. R? visitList(Iterable nodes, A arg) { for (final node in nodes) { node.accept(this, arg); } return null; } /// Visits all children of [node], except for [skip]. void visitExcept(AstNode node, AstNode? skip, A arg) { for (final child in node.childNodes) { if (child != skip) { visit(child, arg); } } } } extension TransformerUtils on Transformer { AstNode? transform(AstNode e, A arg) => visit(e, arg); T transformChild(T child, AstNode parent, A arg) { final transformed = transform(child, arg)!..parent = parent; return transformed as T; } T? transformNullableChild( T? child, AstNode parent, A arg, ) { if (child == null) return null; final transformed = transform(child, arg); transformed?.parent = parent; return transformed as T; } List transformChildren( List children, AstNode parent, A arg) { final newChildren = []; for (final child in children) { // ignore: unnecessary_cast, it's a frontend bug in Dart 2.12 final transformed = transform(child as AstNode, arg) as T?; if (transformed != null) { newChildren.add(transformed..parent = parent); } } return newChildren; } } lib/src/ast/common/queryables.dart 644 0 0 13026 14174332532 15354 0ustar0 pubpubpart of '../ast.dart'; /// Marker interface for something that can appear after a "FROM" in a select /// statement. abstract class Queryable extends AstNode { // todo remove this, introduce more visit methods for subclasses T when({ required T Function(TableReference) isTable, required T Function(SelectStatementAsSource) isSelect, required T Function(JoinClause) isJoin, required T Function(TableValuedFunction) isTableFunction, }) { if (this is TableReference) { return isTable(this as TableReference); } else if (this is SelectStatementAsSource) { return isSelect(this as SelectStatementAsSource); } else if (this is JoinClause) { return isJoin(this as JoinClause); } else if (this is TableValuedFunction) { return isTableFunction(this as TableValuedFunction); } throw StateError('Unknown subclass'); } } /// https://www.sqlite.org/syntax/table-or-subquery.html /// Marker interface abstract class TableOrSubquery extends Queryable { /// The result set that this node made available, if any ResultSetAvailableInStatement? availableResultSet; } /// A table. The first path in https://www.sqlite.org/syntax/table-or-subquery.html /// /// This is both referencable (if we have SELECT * FROM table t), other parts /// of the select statement can access "t") and a reference owner (the table). /// /// Note that this doesn't necessarily resolve to a result set. It could also /// resolve to a common table expression or anything else defining a result /// set. class TableReference extends TableOrSubquery with ReferenceOwner implements Renamable, ResolvesToResultSet { final String? schemaName; final String tableName; Token? tableNameToken; @override final String? as; TableReference(this.tableName, {this.as, this.schemaName}); @override Iterable get childNodes => const []; @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableReference(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override ResultSet? get resultSet { return resolved as ResultSet?; } @override bool get visibleToChildren => true; } /// A nested select statement that appears after a FROM clause. This is /// different from nested select expressions, which can only return one value. class SelectStatementAsSource extends TableOrSubquery implements Renamable { @override final String? as; BaseSelectStatement statement; SelectStatementAsSource({required this.statement, this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSelectStatementAsSource(this, arg); } @override Iterable get childNodes => [statement]; @override void transformChildren(Transformer transformer, A arg) { statement = transformer.transformChild(statement, this, arg); } } /// https://www.sqlite.org/syntax/join-clause.html class JoinClause extends Queryable { TableOrSubquery primary; List joins; JoinClause({required this.primary, required this.joins}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoinClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { primary = transformer.transformChild(primary, this, arg); joins = transformer.transformChildren(joins, this, arg); } @override Iterable get childNodes => [primary, ...joins]; } enum JoinOperator { none, // just JOIN, no other keywords comma, left, leftOuter, inner, cross, } class Join extends AstNode { final bool natural; final JoinOperator operator; TableOrSubquery query; final JoinConstraint? constraint; Join( {this.natural = false, required this.operator, required this.query, this.constraint}); @override Iterable get childNodes { return [ query, if (constraint is OnConstraint) (constraint as OnConstraint).expression ]; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitJoin(this, arg); } @override void transformChildren(Transformer transformer, A arg) { query = transformer.transformChild(query, this, arg); if (constraint is OnConstraint) { final onConstraint = constraint as OnConstraint; onConstraint.expression = transformer.transformChild(onConstraint.expression, this, arg); } } } /// https://www.sqlite.org/syntax/join-constraint.html abstract class JoinConstraint {} class OnConstraint extends JoinConstraint { Expression expression; OnConstraint({required this.expression}); } class UsingConstraint extends JoinConstraint { final List columnNames; UsingConstraint({required this.columnNames}); } class TableValuedFunction extends Queryable implements TableOrSubquery, SqlInvocation, Renamable, ResolvesToResultSet { @override final String name; @override final String? as; @override FunctionParameters parameters; @override ResultSet? resultSet; TableValuedFunction(this.name, this.parameters, {this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableValuedFunction(this, arg); } @override Iterable get childNodes => [parameters]; @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); } @override bool get visibleToChildren => false; @override ResultSetAvailableInStatement? availableResultSet; } lib/src/ast/common/tuple.dart 644 0 0 1557 14047764625 14332 0ustar0 pubpubpart of '../ast.dart'; /// A tuple of values, denotes in brackets. `(, ..., )`. /// /// In sqlite, this is also called a "row value". class Tuple extends Expression { /// The expressions appearing in this tuple. List expressions; /// Whether this tuple is used as an expression, e.g. a [row value][r v]. /// /// Other tuples might appear in `VALUES` clauses. /// /// [r v]: https://www.sqlite.org/rowvalue.html final bool usedAsRowValue; Tuple({required this.expressions, this.usedAsRowValue = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTuple(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expressions = transformer.transformChildren(expressions, this, arg); } @override List get childNodes => expressions; } lib/src/ast/common/renamable.dart 644 0 0 107 14000111271 15041 0ustar0 pubpubpart of '../ast.dart'; abstract class Renamable { String? get as; } lib/src/ast/drift/declared_statement.dart 644 0 0 12321 14213401620 16631 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart' show Variable; import '../expressions/expressions.dart'; import '../node.dart'; import '../statements/statement.dart'; import '../statements/transaction.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// A declared statement inside a `.drift` file. It consists of an identifier, /// followed by a colon and the query to run. class DeclaredStatement extends Statement implements PartOfDriftFile { final DeclaredStatementIdentifier identifier; AstNode statement; List parameters; /// The desired result class name, if set. final String? as; Token? colon; /// Whether this is a regular query, meaning that Dart methods are generated /// for it. Special queries are annotated with an `@` and have special /// meaning. bool get isRegularQuery => identifier is SimpleName; DeclaredStatement(this.identifier, this.statement, {this.parameters = const [], this.as}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statement = transformer.transformChild(statement, this, arg); parameters = transformer.transformChildren(parameters, this, arg); } @override Iterable get childNodes => [statement, ...parameters]; } /// How a statement was declared in a drift file. /// /// We support [SimpleName]s (`name: SELECT * FROM tbl`) and special keywords /// starting with an `@` in abstract class DeclaredStatementIdentifier { String get name; } /// The normal, named statement identifier for regular statements. class SimpleName extends DeclaredStatementIdentifier { @override final String name; IdentifierToken? identifier; SimpleName(this.name); @override int get hashCode => name.hashCode; @override bool operator ==(dynamic other) { return identical(this, other) || (other is SimpleName && other.name == name); } } /// A special statement identifier for statements declared with a `@`-name. /// /// Those names have a special meaning, like running a statement when the /// database is created. class SpecialStatementIdentifier extends DeclaredStatementIdentifier { final String specialName; AtSignVariableToken? nameToken; SpecialStatementIdentifier(this.specialName); @override int get hashCode => specialName.hashCode; @override String get name => specialName; @override bool operator ==(dynamic other) { return identical(this, other) || (other is SpecialStatementIdentifier && other.specialName == specialName); } } /// A statement parameter, which appears between brackets after the statement /// identifier. /// In `selectString(:name AS TEXT): SELECT :name`, `:name AS TEXT` is a /// statement parameter. abstract class StatementParameter extends AstNode implements DriftSpecificNode { @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } } /// Construct to explicitly set a variable type. /// /// Users can use `:name AS TYPE` as a statement parameter. Any use of `:name` /// in the query will then be resolved to the type set here. This is useful for /// cases in which the resolver doesn't yield acceptable results. class VariableTypeHint extends StatementParameter { Variable variable; final bool isRequired; final String? typeName; final bool orNull; Token? as; VariableTypeHint(this.variable, this.typeName, {this.orNull = false, this.isRequired = false}); @override Iterable get childNodes => [variable]; @override void transformChildren(Transformer transformer, A arg) { variable = transformer.transformChild(variable, this, arg); } } /// Set a default value for a dart placeholder. /// /// For instance, /// ``` /// query($predicate = TRUE): SELECT * FROM tbl WHERE $predicate; /// ``` /// /// Would generate an optional `predicate` parameter in Dart, having a default /// value of `CustomExpression('TRUE')`. class DartPlaceholderDefaultValue extends StatementParameter { final String variableName; Expression defaultValue; DollarSignVariableToken? variableToken; DartPlaceholderDefaultValue(this.variableName, this.defaultValue); @override Iterable get childNodes => [defaultValue]; @override void transformChildren(Transformer transformer, A arg) { defaultValue = transformer.transformChild(defaultValue, this, arg); } } class TransactionBlock extends AstNode implements DriftSpecificNode { BeginTransactionStatement begin; List innerStatements; CommitStatement commit; TransactionBlock({ required this.begin, required this.innerStatements, required this.commit, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override Iterable get childNodes => []; @override void transformChildren(Transformer transformer, A arg) { begin = transformer.transformChild(begin, this, arg); innerStatements = transformer.transformChildren(innerStatements, this, arg); commit = transformer.transformChild(commit, this, arg); } } lib/src/ast/drift/drift_file.dart 644 0 0 3223 14213401610 15071 0ustar0 pubpubimport '../node.dart'; import '../statements/statement.dart'; import '../visitor.dart'; import 'declared_statement.dart'; import 'import_statement.dart'; /// Marker interface for AST nodes that are drift-specific. abstract class DriftSpecificNode implements AstNode {} /// Something that can appear as a top-level declaration inside a `.drift` file. abstract class PartOfDriftFile implements Statement, DriftSpecificNode {} /// A parsed `.drift` file. /// /// A drift file consists of [ImportStatement]s, followed by ddl statements, /// followed by [DeclaredStatement]s. class DriftFile extends AstNode implements DriftSpecificNode { List statements; DriftFile(this.statements); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) { statements = transformer.transformChildren(statements, this, arg); } @override Iterable get childNodes => statements; /// Returns the imports defined in this file. Iterable get imports => childNodes.whereType(); } class DriftTableName extends AstNode implements DriftSpecificNode { final String overriddenDataClassName; final bool useExistingDartClass; DriftTableName(this.overriddenDataClassName, this.useExistingDartClass); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/drift/nested_query_column.dart 644 0 0 2641 14206506023 17057 0ustar0 pubpubimport '../ast.dart' show ResultColumn, Renamable, SelectStatement; import '../node.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// To wrap the query name into its own type, to avoid conflicts when using /// the [AstNode] metadata. class _NestedColumnNameMetadata { final String? name; _NestedColumnNameMetadata(this.name); } /// A nested query column, denoted by `LIST(...)` in user queries. /// /// Nested query columns take a select query and execute it for every result /// returned from the main query. Nested query columns can only be added to a /// top level select query, because the result of them can only be computed /// in dart. class NestedQueryColumn extends ResultColumn implements DriftSpecificNode, Renamable { @override final String? as; SelectStatement select; NestedQueryColumn({required this.select, this.as}); @override Iterable get childNodes => [select]; @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } /// The unique name for this query. Used to identify it and it's variables in /// the AST tree. set queryName(String? name) => setMeta(_NestedColumnNameMetadata(name)); String? get queryName => meta<_NestedColumnNameMetadata>()?.name; } lib/src/ast/drift/nested_star_result_column.dart 644 0 0 1652 14213401556 20265 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../ast.dart' show StarResultColumn, ResultColumn, Renamable; import '../node.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// A nested star result column, denoted by `**` in user queries. /// /// Nested star result columns behave similar to a regular [StarResultColumn] /// when the query is actually run. However, they will affect generated code /// when using drift. class NestedStarResultColumn extends ResultColumn implements DriftSpecificNode, Renamable { final String tableName; ResultSet? resultSet; @override final String? as; NestedStarResultColumn({required this.tableName, this.as}); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } } lib/src/ast/drift/import_statement.dart 644 0 0 1270 14213401601 16360 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../node.dart'; import '../statements/statement.dart'; import '../visitor.dart'; import 'drift_file.dart'; /// An `import "file.dart";` statement that can appear inside a drift file. class ImportStatement extends Statement implements PartOfDriftFile { Token? importToken; StringLiteralToken? importString; final String importedFile; ImportStatement(this.importedFile); @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override final Iterable childNodes = const []; } lib/src/ast/drift/inline_dart.dart 644 0 0 5503 14213401575 15267 0ustar0 pubpubimport '../../reader/tokenizer/token.dart'; import '../ast.dart'; /// An inline Dart component that appears in a compiled sql query. Inline Dart /// components can be bound with complex expressions at runtime by using drift's /// Dart API. /// /// At the moment, we support 4 kind of inline components: /// 1. expressions: Any expression can be used for drift: `SELECT * FROM table /// = $expr`. Generated code will write this as an `Expression` class from /// drift. /// 2. limits, which will be exposed as a `Limit` component from drift /// 3. A single order-by clause, which will be exposed as a `OrderingTerm` from /// drift. /// 4. A list of order-by clauses, which will be exposed as a `OrderBy` from /// drift. abstract class DartPlaceholder extends AstNode implements DriftSpecificNode { final String name; DollarSignVariableToken? token; DartPlaceholder._(this.name); @override final Iterable childNodes = const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} @override R accept(AstVisitor visitor, A arg) { return visitor.visitDriftSpecificNode(this, arg); } T? when({ T Function(DartExpressionPlaceholder)? isExpression, T Function(DartLimitPlaceholder)? isLimit, T Function(DartOrderingTermPlaceholder)? isOrderingTerm, T Function(DartOrderByPlaceholder)? isOrderBy, T Function(DartInsertablePlaceholder)? isInsertable, }) { if (this is DartExpressionPlaceholder) { return isExpression?.call(this as DartExpressionPlaceholder); } else if (this is DartLimitPlaceholder) { return isLimit?.call(this as DartLimitPlaceholder); } else if (this is DartOrderingTermPlaceholder) { return isOrderingTerm?.call(this as DartOrderingTermPlaceholder); } else if (this is DartOrderByPlaceholder) { return isOrderBy?.call(this as DartOrderByPlaceholder); } else if (this is DartInsertablePlaceholder) { return isInsertable?.call(this as DartInsertablePlaceholder); } throw AssertionError('Invalid placeholder: $runtimeType'); } } class DartExpressionPlaceholder extends DartPlaceholder implements Expression { DartExpressionPlaceholder({required String name}) : super._(name); } class DartLimitPlaceholder extends DartPlaceholder implements LimitBase { DartLimitPlaceholder({required String name}) : super._(name); } class DartOrderingTermPlaceholder extends DartPlaceholder implements OrderingTermBase { DartOrderingTermPlaceholder({required String name}) : super._(name); } class DartOrderByPlaceholder extends DartPlaceholder implements OrderByBase { DartOrderByPlaceholder({required String name}) : super._(name); } class DartInsertablePlaceholder extends DartPlaceholder implements InsertSource { DartInsertablePlaceholder({required String name}) : super._(name); } lib/src/ast/node.dart 644 0 0 11050 14200761154 12624 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/reader/syntactic_entity.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:sqlparser/src/utils/meta.dart'; import 'ast.dart'; // todo: Remove this import after untangling the library /// A node in the abstract syntax tree of an SQL statement. abstract class AstNode with HasMetaMixin implements SyntacticEntity { /// The parent of this node, or null if this is the root node. Will be set /// by the analyzer after the tree has been parsed. AstNode? parent; /// The first token that appears in this node. This information is not set for /// all nodes. Token? first; /// The last token that appears in this node. This information is not set for /// all nodes. Token? last; @override bool synthetic = false; @override int get firstPosition => first!.span.start.offset; @override int get lastPosition => last!.span.end.offset; @override FileSpan? get span { if (!hasSpan) return null; return first!.span.expand(last!.span); } @override bool get hasSpan => first != null && last != null; /// Sets the [AstNode.first] and [AstNode.last] property in one go. void setSpan(Token first, Token last) { this.first = first; this.last = last; } /// Returns all parents of this node up to the root. If this node is the root, /// the iterable will be empty. Iterable get parents sync* { var node = parent; while (node != null) { yield node; node = node.parent; } } /// Returns an iterable containing `this` node and all [parents]. Iterable get selfAndParents sync* { yield this; yield* parents; } /// Recursively returns all descendants of this node, e.g. its children, their /// children and so on. The tree will be pre-order traversed. Iterable get allDescendants sync* { for (final child in childNodes) { yield child; yield* child.allDescendants; } } /// Returns an iterable that fields yields this node, followed by /// [allDescendants]. Iterable get selfAndDescendants sync* { yield this; yield* allDescendants; } bool isChildOf(AstNode other) => parents.contains(other); /// Finds the first element in [selfAndParents] of the type [T]. /// /// Returns `null` if there's no node of type [T] surrounding this ast node. T? enclosingOfType() { for (final element in selfAndParents) { if (element is T) { return element; } } return null; } /// The [ReferenceScope], which contains available tables, column references /// and functions for this node. ReferenceScope get scope { AstNode? node = this; while (node != null) { final scope = node.meta(); if (scope != null) return scope; node = node.parent; } throw StateError('No reference scope found in this or any parent node'); } /// Applies a [ReferenceScope] to this node. Variables declared in [scope] /// will be visible to this node and to [allDescendants]. set scope(ReferenceScope scope) { setMeta(scope); } /// All direct children of this node. Iterable get childNodes; /// Calls the appropriate method on the [visitor] to make it recognize this /// node. R accept(AstVisitor visitor, A arg); /// Like [accept], but without an argument. /// /// Null will be used for the argument instead. R acceptWithoutArg(AstVisitor visitor) { return accept(visitor, null); } /// Transforms children of this node by invoking [transformer] with the /// argument [arg]. void transformChildren(Transformer transformer, A arg); /// Whether the content of this node is equal to the [other] node of the same /// type. The "content" refers to anything stored only in this node, children /// are ignored. @nonVirtual bool contentEquals(AstNode other) { final checker = EqualityEnforcingVisitor(this, considerChildren: false); try { checker.visit(other, null); return true; } on NotEqualException { return false; } } @override String toString() { if (hasSpan) { return '$runtimeType: ${span!.text}'; } return super.toString(); } } /// Common interface for every node that has a `where` clause. abstract class HasWhereClause implements AstNode { Expression? get where; } lib/src/ast/schema/column_definition.dart 644 0 0 16275 14206506035 16663 0ustar0 pubpubpart of '../ast.dart'; /// https://www.sqlite.org/syntax/column-def.html class ColumnDefinition extends AstNode { final String columnName; final String? typeName; List constraints; /// The tokens there were involved in defining the type of this column. List? typeNames; Token? nameToken; ColumnDefinition( {required this.columnName, required this.typeName, this.constraints = const []}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitColumnDefinition(this, arg); } @override void transformChildren(Transformer transformer, A arg) { constraints = transformer.transformChildren(constraints, this, arg); } @override Iterable get childNodes => constraints; bool get isNonNullable => findConstraint() != null; /// Finds a constraint of type [T], or null, if none is set. T? findConstraint() { final typedConstraints = constraints.whereType().iterator; if (typedConstraints.moveNext()) { return typedConstraints.current; } return null; } } /// https://www.sqlite.org/syntax/column-constraint.html abstract class ColumnConstraint extends AstNode { final String? name; ColumnConstraint(this.name); @override R accept(AstVisitor visitor, A arg) { return visitor.visitColumnConstraint(this, arg); } T? when({ T Function(NotNull)? notNull, T Function(NullColumnConstraint)? nullable, T Function(PrimaryKeyColumn)? primaryKey, T Function(UniqueColumn)? unique, T Function(CheckColumn)? check, T Function(Default)? isDefault, T Function(CollateConstraint)? collate, T Function(ForeignKeyColumnConstraint)? foreignKey, T Function(MappedBy)? mappedBy, T Function(GeneratedAs)? generatedAs, }) { if (this is NotNull) { return notNull?.call(this as NotNull); } else if (this is NullColumnConstraint) { return nullable?.call(this as NullColumnConstraint); } else if (this is PrimaryKeyColumn) { return primaryKey?.call(this as PrimaryKeyColumn); } else if (this is UniqueColumn) { return unique?.call(this as UniqueColumn); } else if (this is CheckColumn) { return check?.call(this as CheckColumn); } else if (this is Default) { return isDefault?.call(this as Default); } else if (this is CollateConstraint) { return collate?.call(this as CollateConstraint); } else if (this is ForeignKeyColumnConstraint) { return foreignKey?.call(this as ForeignKeyColumnConstraint); } else if (this is MappedBy) { return mappedBy?.call(this as MappedBy); } else if (this is GeneratedAs) { return generatedAs?.call(this as GeneratedAs); } else { throw Exception('Did not expect $runtimeType as a ColumnConstraint'); } } } enum ConflictClause { rollback, abort, fail, ignore, replace } class NullColumnConstraint extends ColumnConstraint { /// The `NULL` token forming this constraint. Token? $null; NullColumnConstraint(String? name, {this.$null}) : super(name); @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } class NotNull extends ColumnConstraint { final ConflictClause? onConflict; Token? not; Token? $null; NotNull(String? name, {this.onConflict}) : super(name); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } class PrimaryKeyColumn extends ColumnConstraint { final bool autoIncrement; final ConflictClause? onConflict; final OrderingMode? mode; PrimaryKeyColumn(String? name, {this.autoIncrement = false, this.mode, this.onConflict}) : super(name); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} } class UniqueColumn extends ColumnConstraint { final ConflictClause? onConflict; UniqueColumn(String? name, this.onConflict) : super(name); @override Iterable get childNodes => const []; @override void transformChildren(Transformer transformer, A arg) {} } class CheckColumn extends ColumnConstraint { Expression expression; CheckColumn(String? name, this.expression) : super(name); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } class Default extends ColumnConstraint { Expression expression; Default(String? name, this.expression) : super(name); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } class CollateConstraint extends ColumnConstraint { final String collation; CollateConstraint(String? name, this.collation) : super(name); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } class ForeignKeyColumnConstraint extends ColumnConstraint { ForeignKeyClause clause; ForeignKeyColumnConstraint(String? name, this.clause) : super(name); @override Iterable get childNodes => [clause]; @override void transformChildren(Transformer transformer, A arg) { clause = transformer.transformChild(clause, this, arg); } } class GeneratedAs extends ColumnConstraint { Expression expression; bool stored; GeneratedAs(this.expression, {this.stored = false, String? name}) : super(name); @override Iterable get childNodes => [expression]; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } } /// A `MAPPED BY` constraint, which is only parsed for drift files. It can be /// used to declare a type converter for this column. class MappedBy extends ColumnConstraint { /// The Dart expression creating the type converter we use to map this token. final InlineDartToken mapper; MappedBy(String? name, this.mapper) : super(name); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} } /// A `JSON KEY xyz` constraint, which is only parsed for drift files. class JsonKey extends ColumnConstraint { Token? json; Token? key; IdentifierToken jsonNameToken; @override final Iterable childNodes = const []; String get jsonKey => jsonNameToken.identifier; JsonKey(String? name, this.jsonNameToken) : super(name); @override void transformChildren(Transformer transformer, A arg) {} } /// A `AS xyz` constraint, which is only parsed for drift files. class DriftDartName extends ColumnConstraint { Token? as; IdentifierToken identifier; @override final Iterable childNodes = const []; String get dartName => identifier.identifier; DriftDartName(String? name, this.identifier) : super(name); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/schema/table_definition.dart 644 0 0 7447 14047764625 16454 0ustar0 pubpubpart of '../ast.dart'; enum ReferenceAction { setNull, setDefault, cascade, restrict, noAction } class ForeignKeyClause extends AstNode { TableReference foreignTable; List columnNames; final ReferenceAction? onDelete; final ReferenceAction? onUpdate; DeferrableClause? deferrable; ForeignKeyClause({ required this.foreignTable, required this.columnNames, this.onDelete, this.onUpdate, this.deferrable, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitForeignKeyClause(this, arg); } @override void transformChildren(Transformer transformer, A arg) { foreignTable = transformer.transformChild(foreignTable, this, arg); columnNames = transformer.transformChildren(columnNames, this, arg); deferrable = transformer.transformChild(deferrable!, this, arg); } @override Iterable get childNodes => [ foreignTable, ...columnNames, if (deferrable != null) deferrable!, ]; } enum InitialDeferrableMode { deferred, immediate, } class DeferrableClause extends AstNode { final bool not; final InitialDeferrableMode? declaredInitially; DeferrableClause(this.not, this.declaredInitially); InitialDeferrableMode? get effectiveInitialMode { if (not || declaredInitially == null) { return InitialDeferrableMode.immediate; } return declaredInitially; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitDeferrableClause(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } abstract class TableConstraint extends AstNode { final String? name; Token? nameToken; TableConstraint(this.name); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTableConstraint(this, arg); } bool constraintEquals(covariant TableConstraint other); } class KeyClause extends TableConstraint { final bool isPrimaryKey; List columns; final ConflictClause? onConflict; bool get isUnique => !isPrimaryKey; @Deprecated('Use columns instead') List get indexedColumns { return [ for (final column in columns) if (column.expression is Reference) column.expression as Reference ]; } KeyClause(String? name, {required this.isPrimaryKey, required this.columns, this.onConflict}) : super(name); @override bool constraintEquals(KeyClause other) { return other.isPrimaryKey == isPrimaryKey && other.onConflict == onConflict; } @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); } @override Iterable get childNodes => columns; } class CheckTable extends TableConstraint { Expression expression; CheckTable(String? name, this.expression) : super(name); @override bool constraintEquals(CheckTable other) => true; @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } class ForeignKeyTableConstraint extends TableConstraint { List columns; ForeignKeyClause clause; ForeignKeyTableConstraint(String? name, {required this.columns, required this.clause}) : super(name); @override bool constraintEquals(ForeignKeyTableConstraint other) => true; @override void transformChildren(Transformer transformer, A arg) { columns = transformer.transformChildren(columns, this, arg); clause = transformer.transformChild(clause, this, arg); } @override Iterable get childNodes => [...columns, clause]; } lib/src/ast/ast.dart 644 0 0 3334 14206506030 12450 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'drift/inline_dart.dart'; import 'expressions/expressions.dart'; import 'node.dart'; import 'statements/create_index.dart'; import 'statements/select.dart'; import 'visitor.dart'; export 'clauses/returning.dart'; export 'clauses/upsert.dart'; export 'drift/declared_statement.dart'; export 'drift/drift_file.dart'; export 'drift/import_statement.dart'; export 'drift/inline_dart.dart'; export 'drift/nested_query_column.dart'; export 'drift/nested_star_result_column.dart'; export 'expressions/expressions.dart'; export 'expressions/raise.dart'; export 'node.dart'; export 'statements/block.dart'; export 'statements/create_index.dart'; export 'statements/create_table.dart'; export 'statements/create_trigger.dart'; export 'statements/create_view.dart'; export 'statements/delete.dart'; export 'statements/insert.dart'; export 'statements/invalid.dart'; export 'statements/select.dart'; export 'statements/statement.dart'; export 'statements/transaction.dart'; export 'statements/update.dart'; export 'visitor.dart'; // todo: Split up this mega-library part 'clauses/limit.dart'; part 'clauses/ordering.dart'; part 'clauses/with.dart'; part 'common/queryables.dart'; part 'common/renamable.dart'; part 'common/tuple.dart'; part 'expressions/aggregate.dart'; part 'expressions/case.dart'; part 'expressions/cast.dart'; part 'expressions/function.dart'; part 'expressions/literals.dart'; part 'expressions/reference.dart'; part 'expressions/simple.dart'; part 'expressions/subquery.dart'; part 'expressions/variables.dart'; part 'schema/column_definition.dart'; part 'schema/table_definition.dart'; lib/src/ast/expressions/subquery.dart 644 0 0 1750 14000111271 16111 0ustar0 pubpubpart of '../ast.dart'; /// A subquery, which is an expression. It is expected that the inner query /// only returns one column and one row. class SubQuery extends Expression { BaseSelectStatement select; SubQuery({required this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitSubQuery(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override Iterable get childNodes => [select]; } class ExistsExpression extends Expression { BaseSelectStatement select; ExistsExpression({required this.select}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExists(this, arg); } @override void transformChildren(Transformer transformer, A arg) { select = transformer.transformChild(select, this, arg); } @override Iterable get childNodes => [select]; } lib/src/ast/expressions/reference.dart 644 0 0 3200 14131303604 16170 0ustar0 pubpubpart of '../ast.dart'; /// Expression that refers to an individual expression declared somewhere else /// in the table. /// /// For instance, in "SELECT table.c FROM table", the "table.c" is a reference /// that refers to the column "c" in a table "table". In "SELECT COUNT(*) AS c, /// 2 * c AS d FROM table", the "c" after the "2 *" is a reference that refers /// to the expression "COUNT(*)". class Reference extends Expression with ReferenceOwner { /// An optional schema name. /// /// When this is non-null, [entityName] will not be null either. final String? schemaName; /// Entity can be either a table or a view. final String? entityName; final String columnName; /// The resolved result set from the [entityName]. ResultSetAvailableInStatement? resultEntity; Column? get resolvedColumn => resolved as Column?; Reference({this.entityName, this.schemaName, required this.columnName}) : assert( entityName != null || schemaName == null, 'When setting a schemaName, entityName must not be null either.', ); @override R accept(AstVisitor visitor, A arg) { return visitor.visitReference(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; @override String toString() { final result = StringBuffer(); if (schemaName != null) { result ..write(schemaName) ..write('.'); } if (entityName != null) { result ..write(entityName) ..write('.'); } result.write(columnName); return result.toString(); } } lib/src/ast/expressions/simple.dart 644 0 0 12664 14155120333 15563 0ustar0 pubpubpart of '../ast.dart'; class UnaryExpression extends Expression { final Token operator; Expression inner; UnaryExpression(this.operator, this.inner); @override R accept(AstVisitor visitor, A arg) { return visitor.visitUnaryExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { inner = transformer.transformChild(inner, this, arg); } @override Iterable get childNodes => [inner]; } class CollateExpression extends UnaryExpression { final Token collateFunction; String get collation => collateFunction.lexeme; CollateExpression( {required Token operator, required Expression inner, required this.collateFunction}) : super(operator, inner); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCollateExpression(this, arg); } } class BinaryExpression extends Expression { final Token operator; Expression left; Expression right; BinaryExpression(this.left, this.operator, this.right); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBinaryExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); } @override Iterable get childNodes => [left, right]; } /// A like, glob, match or regexp expression. class StringComparisonExpression extends Expression { final bool not; final Token operator; Expression left; Expression right; Expression? escape; StringComparisonExpression( {this.not = false, required this.left, required this.operator, required this.right, this.escape}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitStringComparison(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); escape = transformer.transformNullableChild(escape, this, arg); } @override Iterable get childNodes => [left, right, if (escape != null) escape!]; } /// `(NOT)? $left IS $right` class IsExpression extends Expression { final bool negated; Expression left; Expression right; IsExpression(this.negated, this.left, this.right); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIsExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); right = transformer.transformChild(right, this, arg); } @override Iterable get childNodes => [left, right]; } class IsNullExpression extends Expression { Expression operand; /// When true, this is a `NOT NULL` expression. final bool negated; IsNullExpression(this.operand, [this.negated = false]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitIsNullExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { operand = transformer.transformChild(operand, this, arg); } @override Iterable get childNodes => [operand]; } /// `$check BETWEEN $lower AND $upper` class BetweenExpression extends Expression { final bool not; Expression check; Expression lower; Expression upper; BetweenExpression( {this.not = false, required this.check, required this.lower, required this.upper}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBetweenExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { check = transformer.transformChild(check, this, arg); lower = transformer.transformChild(lower, this, arg); upper = transformer.transformChild(upper, this, arg); } @override List get childNodes => [check, lower, upper]; } /// `$left$ IN $inside`. class InExpression extends Expression { final bool not; Expression left; /// The right-hand part: Contains the set of values [left] will be tested /// against. From the sqlite grammar, we support [Tuple] and a [SubQuery]. /// We also support a [Variable] as syntax sugar - it will be expanded into a /// tuple of variables at runtime. Expression inside; InExpression({this.not = false, required this.left, required this.inside}) : assert(inside is Tuple || inside is Variable || inside is SubQuery); @override R accept(AstVisitor visitor, A arg) { return visitor.visitInExpression(this, arg); } @override List get childNodes => [left, inside]; @override void transformChildren(Transformer transformer, A arg) { left = transformer.transformChild(left, this, arg); inside = transformer.transformChild(inside, this, arg); } } class Parentheses extends Expression { Token? openingLeft; Token? closingRight; Expression expression; Parentheses(this.expression); @override R accept(AstVisitor visitor, A arg) { return visitor.visitParentheses(this, arg); } @override void transformChildren(Transformer transformer, A arg) { expression = transformer.transformChild(expression, this, arg); } @override Iterable get childNodes => [expression]; } lib/src/ast/expressions/cast.dart 644 0 0 1024 14000111271 15156 0ustar0 pubpubpart of '../ast.dart'; /// A `CAST( AS )` expression. class CastExpression extends Expression { Expression operand; final String typeName; CastExpression(this.operand, this.typeName); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCastExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { operand = transformer.transformChild(operand, this, arg); } @override Iterable get childNodes => [operand]; } lib/src/ast/expressions/literals.dart 644 0 0 4233 14000111271 16050 0ustar0 pubpubpart of '../ast.dart'; // https://www.sqlite.org/syntax/literal-value.html @optionalTypeArgs abstract class Literal extends Expression { final Token token; T get value; Literal(this.token); @override final Iterable childNodes = const []; @override void transformChildren(Transformer transformer, A arg) {} @override String toString() { return 'Literal with value $value'; } } class NullLiteral extends Literal { NullLiteral(Token token) : super(token); @override Null get value => null; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNullLiteral(this, arg); } } class NumericLiteral extends Literal { @override final num value; bool get isInt => value is int; NumericLiteral(this.value, Token token) : super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumericLiteral(this, arg); } } class BooleanLiteral extends Literal { @override final bool value; BooleanLiteral.withFalse(Token token) : value = false, super(token); BooleanLiteral.withTrue(Token token) : value = true, super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitBooleanLiteral(this, arg); } } class StringLiteral extends Literal { @override final String value; final bool isBinary; StringLiteral(StringLiteralToken token) : value = token.value, isBinary = token.binary, super(token); StringLiteral.from(Token token, this.value, {this.isBinary = false}) : super(token); @override R accept(AstVisitor visitor, A arg) { return visitor.visitStringLiteral(this, arg); } } enum TimeConstantKind { currentTime, currentDate, currentTimestamp } class TimeConstantLiteral extends Literal { final TimeConstantKind kind; TimeConstantLiteral(this.kind, Token keyword) : super(keyword); @override R accept(AstVisitor visitor, A arg) { return visitor.visitTimeConstantLiteral(this, arg); } @override dynamic get value => throw UnimplementedError('TimeConstantLiteral.value'); } lib/src/ast/expressions/raise.dart 644 0 0 1313 14047764625 15364 0ustar0 pubpubimport '../node.dart'; import '../visitor.dart'; import 'expressions.dart'; enum RaiseKind { ignore, rollback, abort, fail, } class RaiseExpression extends Expression { final RaiseKind raiseKind; /// The user-defined error message for this `RAISE` expression. /// /// This will be non-null if [raiseKind] is not [RaiseKind.ignore]. final String? errorMessage; RaiseExpression(this.raiseKind, [this.errorMessage]); @override R accept(AstVisitor visitor, A arg) { return visitor.visitRaiseExpression(this, arg); } @override Iterable get childNodes => const Iterable.empty(); @override void transformChildren(Transformer transformer, A arg) {} } lib/src/ast/expressions/variables.dart 644 0 0 2206 14200761154 16214 0ustar0 pubpubpart of '../ast.dart'; abstract class Variable extends Expression { int? resolvedIndex; } /// A "?" or "?123" variable placeholder class NumberedVariable extends Expression implements Variable { final QuestionMarkVariableToken token; int? get explicitIndex => token.explicitIndex; @override int? resolvedIndex; NumberedVariable(this.token) { resolvedIndex = token.explicitIndex; } @override R accept(AstVisitor visitor, A arg) { return visitor.visitNumberedVariable(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const []; } class ColonNamedVariable extends Expression implements Variable { final String name; @override int? resolvedIndex; ColonNamedVariable.synthetic(this.name); ColonNamedVariable(ColonVariableToken token) : name = token.name; @override R accept(AstVisitor visitor, A arg) { return visitor.visitNamedVariable(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => []; } lib/src/ast/expressions/function.dart 644 0 0 4462 14211667321 16102 0ustar0 pubpubpart of '../ast.dart'; /// Interface for function calls. /// /// Functions that resolve to an [Expression] are subclasses of /// [ExpressionInvocation], like [FunctionExpression] or /// [AggregateFunctionInvocation]. There are invocations that don't resolve to /// an expression, notably [TableValuedFunction]s. abstract class SqlInvocation implements AstNode { /// The name of the function being called String get name; FunctionParameters get parameters; } /// Interface for [SqlInvocation]s that are also expressions. abstract class ExpressionInvocation implements SqlInvocation, Expression {} class FunctionExpression extends Expression with ReferenceOwner implements ExpressionInvocation { @override final String name; @override FunctionParameters parameters; FunctionExpression({required this.name, required this.parameters}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFunction(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); } @override Iterable get childNodes { return [parameters]; } } /// Marker interface for anything that can be inside the parentheses after a /// function name. abstract class FunctionParameters extends AstNode {} /// Using a star as a function parameter. For instance: "COUNT(*)". class StarFunctionParameter extends FunctionParameters { StarFunctionParameter(); Token? starToken; @override R accept(AstVisitor visitor, A arg) { return visitor.visitStarFunctionParameter(this, arg); } @override void transformChildren(Transformer transformer, A arg) {} @override Iterable get childNodes => const Iterable.empty(); } class ExprFunctionParameters extends FunctionParameters { final bool distinct; List parameters; ExprFunctionParameters({this.parameters = const [], this.distinct = false}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitExpressionFunctionParameters(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChildren(parameters, this, arg); } @override List get childNodes => parameters; } lib/src/ast/expressions/case.dart 644 0 0 2333 14047764625 15177 0ustar0 pubpubpart of '../ast.dart'; class CaseExpression extends Expression { Expression? base; List whens; Expression? elseExpr; CaseExpression({this.base, required this.whens, this.elseExpr}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitCaseExpression(this, arg); } @override void transformChildren(Transformer transformer, A arg) { base = transformer.transformNullableChild(base, this, arg); whens = transformer.transformChildren(whens, this, arg); elseExpr = transformer.transformNullableChild(elseExpr, this, arg); } @override Iterable get childNodes => [if (base != null) base!, ...whens, if (elseExpr != null) elseExpr!]; } class WhenComponent extends AstNode { Expression when; Expression then; WhenComponent({required this.when, required this.then}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWhen(this, arg); } @override void transformChildren(Transformer transformer, A arg) { when = transformer.transformChild(when, this, arg); then = transformer.transformChild(then, this, arg); } @override Iterable get childNodes => [when, then]; } lib/src/ast/expressions/aggregate.dart 644 0 0 17060 14211621222 16207 0ustar0 pubpubpart of '../ast.dart'; class AggregateFunctionInvocation extends Expression implements ExpressionInvocation, ReferenceOwner { final IdentifierToken function; @override String get name => function.identifier; @override FunctionParameters parameters; Expression? filter; @override Referencable? resolved; AggregateFunctionInvocation({ required this.function, required this.parameters, this.filter, }); @override R accept(AstVisitor visitor, A arg) { return visitor.visitAggregateFunctionInvocation(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); filter = transformer.transformNullableChild(filter, this, arg); } @override Iterable get childNodes { return [parameters, if (filter != null) filter!]; } } class WindowFunctionInvocation extends AggregateFunctionInvocation { WindowDefinition? get over { if (windowDefinition != null) return windowDefinition; return (resolved as NamedWindowDeclaration?)?.definition; } /// The window definition as declared in the `OVER` clause in sql. If this /// aggregate expression didn't declare a window (e.g. it instead uses a /// window via a name declared in the surrounding `SELECT` statement), we're /// this field will be null. Either [windowDefinition] or [windowName] are /// null. The resolved [WindowDefinition] is available in [over] in either /// case. WindowDefinition? windowDefinition; /// An aggregate expression can be written as `OVER ` instead of /// declaring its own [windowDefinition]. Either [windowDefinition] or /// [windowName] are null. The resolved [WindowDefinition] is available in /// [over] in either case. final String? windowName; WindowFunctionInvocation( {required IdentifierToken function, required FunctionParameters parameters, Expression? filter, this.windowDefinition, this.windowName}) // one of window definition or name must be null : assert((windowDefinition == null) || (windowName == null)), super(function: function, parameters: parameters, filter: filter); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWindowFunctionInvocation(this, arg); } @override void transformChildren(Transformer transformer, A arg) { parameters = transformer.transformChild(parameters, this, arg); filter = transformer.transformNullableChild(filter, this, arg); windowDefinition = transformer.transformNullableChild(windowDefinition, this, arg); } @override Iterable get childNodes { return [ parameters, if (filter != null) filter!, if (windowDefinition != null) windowDefinition!, ]; } } /// A window declaration that appears in a `SELECT` statement like /// `WINDOW AS `. It can be referenced from an /// [AggregateFunctionInvocation] if it uses the same name. class NamedWindowDeclaration with Referencable { // todo: Should be an ast node final String name; final WindowDefinition definition; NamedWindowDeclaration(this.name, this.definition); } class WindowDefinition extends AstNode { final String? baseWindowName; List partitionBy; OrderByBase? orderBy; FrameSpec frameSpec; WindowDefinition( {this.baseWindowName, this.partitionBy = const [], this.orderBy, required this.frameSpec}); @override R accept(AstVisitor visitor, A arg) { return visitor.visitWindowDefinition(this, arg); } @override void transformChildren(Transformer transformer, A arg) { partitionBy = transformer.transformChildren(partitionBy, this, arg); orderBy = transformer.transformNullableChild(orderBy, this, arg); frameSpec = transformer.transformChild(frameSpec, this, arg); } @override Iterable get childNodes => [...partitionBy, if (orderBy != null) orderBy!, frameSpec]; } class FrameSpec extends AstNode { final FrameType? type; final ExcludeMode? excludeMode; FrameBoundary start; FrameBoundary end; FrameSpec({ this.type = FrameType.range, FrameBoundary? start, FrameBoundary? end, this.excludeMode = ExcludeMode.noOthers, }) : start = start ?? FrameBoundary.unboundedPreceding(), end = end ?? FrameBoundary.currentRow(); @override R accept(AstVisitor visitor, A arg) { return visitor.visitFrameSpec(this, arg); } @override void transformChildren(Transformer transformer, A arg) { if (start.isExpressionOffset) { start.offset = transformer.transformChild(start.offset!, this, arg); } if (end.isExpressionOffset) { end.offset = transformer.transformChild(end.offset!, this, arg); } } @override Iterable get childNodes => [ if (start.isExpressionOffset) start.offset!, if (end.isExpressionOffset) end.offset!, ]; } /// Defines how a [FrameBoundary] count rows or groups. See /// https://www.sqlite.org/windowfunctions.html#frame_type for details. enum FrameType { rows, groups, range } /// Defines if rows are omitted inside a [FrameBoundary]. enum ExcludeMode { /// default, no rows are excluded from the window frame noOthers, /// the current row is excluded from the window frame currentRow, /// The row and and its peers (rows considered to be equal to the ORDER BY /// clause) are excluded group, /// Peers of the row are excluded (see [group]), but not the row itself. ties, } enum _BoundaryType { currentRow, exprOffset, unboundedOffset, } /// Defines how many rows before or after a current row should be included in /// a window. class FrameBoundary { final _BoundaryType _type; /// The (integer) expression that specifies the amount of rows to include /// before or after the row being processed. Expression? offset; /// Whether this boundary refers to a row before the current row. final bool preceding; bool get following => !preceding; /// Whether this boundary is a ` PRECEDING` or ` FOLLOWING` /// boundary. bool get isExpressionOffset => _type == _BoundaryType.exprOffset; /// Whether this boundary is a `UNBOUNDED PRECEDING` or `UNBOUNDED FOLLOWING`. bool get isUnbounded => _type == _BoundaryType.unboundedOffset; /// Whether this boundary only refers to the current row. bool get isCurrentRow => _type == _BoundaryType.currentRow; FrameBoundary._(this._type, this.preceding, {this.offset}); FrameBoundary.unboundedPreceding() : this._(_BoundaryType.unboundedOffset, true); FrameBoundary.unboundedFollowing() : this._(_BoundaryType.unboundedOffset, false); FrameBoundary.currentRow() : this._(_BoundaryType.currentRow, false); FrameBoundary.preceding(Expression amount) : this._(_BoundaryType.exprOffset, true, offset: amount); FrameBoundary.following(Expression amount) : this._(_BoundaryType.exprOffset, false, offset: amount); @override int get hashCode { return (preceding ? 2 : 3) * (5 * offset.hashCode + _type.hashCode); } @override bool operator ==(dynamic other) { if (identical(this, other)) return true; if (other.runtimeType != runtimeType) return false; // lint bug: https://github.com/dart-lang/linter/issues/1397 final typedOther = other as FrameBoundary; // ignore: test_types_in_equals return typedOther._type == _type && (typedOther.offset == null && offset == null || typedOther.offset!.contentEquals(offset!)) && typedOther.preceding == preceding; } } lib/src/ast/expressions/expressions.dart 644 0 0 200 14025064205 16574 0ustar0 pubpubimport '../../analysis/analysis.dart'; import '../node.dart'; abstract class Expression extends AstNode implements Typeable {} lib/src/reader/parser.dart 644 0 0 251142 14211621427 13676 0ustar0 pubpubimport 'package:source_span/source_span.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; const _comparisonOperators = [ TokenType.less, TokenType.lessEqual, TokenType.more, TokenType.moreEqual, ]; const _binaryOperators = [ TokenType.shiftLeft, TokenType.shiftRight, TokenType.ampersand, TokenType.pipe, ]; class ParsingError implements Exception { final Token token; final String message; ParsingError(this.token, this.message); @override String toString() { return token.span.message('Error: $message'); } } class Parser { final List tokens; final List errors = []; final AutoCompleteEngine? autoComplete; // todo remove this and don't be that lazy in driftFile() var _lastStmtHadParsingError = false; /// Whether to enable the extensions drift makes to the sql grammar. final bool enableDriftExtensions; int _current = 0; Parser(this.tokens, {bool useDrift = false, this.autoComplete}) : enableDriftExtensions = useDrift; bool get _reportAutoComplete => autoComplete != null; void _suggestHint(HintDescription description) { final tokenBefore = _current == 0 ? null : _previous; autoComplete?.addHint(Hint(tokenBefore, description)); } void _suggestHintForTokens(Iterable types) { final relevant = types.where(isKeyword).map((type) => HintDescription.token(type)); final description = CombinedDescription()..descriptions.addAll(relevant); _suggestHint(description); } void _suggestHintForToken(TokenType type) { if (isKeyword(type)) { _suggestHint(HintDescription.token(type)); } } bool get _isAtEnd => _peek.type == TokenType.eof; Token get _peek => tokens[_current]; Token get _peekNext => tokens[_current + 1]; Token get _previous => tokens[_current - 1]; bool _match(Iterable types) { if (_reportAutoComplete) _suggestHintForTokens(types); for (final type in types) { if (_check(type)) { _advance(); return true; } } return false; } bool _matchOne(TokenType type) { if (_reportAutoComplete) _suggestHintForToken(type); if (_check(type)) { _advance(); return true; } return false; } /// Returns true if the next token is [type] or if the next two tokens are /// "NOT" followed by [type]. Does not consume any tokens. bool _checkWithNot(TokenType type) { if (_check(type)) return true; if (_check(TokenType.not) && _peekNext.type == type) return true; return false; } /// Like [_checkWithNot], but with more than one token type. bool _checkAnyWithNot(List types) { if (types.any(_check)) return true; if (_check(TokenType.not) && types.contains(_peekNext.type)) return true; return false; } bool _check(TokenType type) { if (_reportAutoComplete) _suggestHintForToken(type); if (_isAtEnd) return false; return _peek.type == type; } bool _checkAny(Iterable type) { if (_isAtEnd) return false; return type.contains(_peek.type); } /// Returns whether the next token is an [TokenType.identifier] or a /// [KeywordToken]. If this method returns true, calling [_consumeIdentifier] /// with same [lenient] parameter will now throw. bool _checkIdentifier({bool lenient = false}) { final next = _peek; if (next.type == TokenType.identifier) return true; return next is KeywordToken && (next.canConvertToIdentifier() || lenient); } Token _advance() { if (!_isAtEnd) { _current++; } return _previous; } Never _error(String message) { final error = ParsingError(_peek, message); errors.add(error); throw error; } Token _consume(TokenType type, [String? message]) { if (_check(type)) return _advance(); _error(message ?? 'Expected $type'); } /// Consumes an identifier. IdentifierToken _consumeIdentifier(String message, {bool lenient = false}) { final next = _peek; // non-standard keywords can be parsed as an identifier, we allow all // keywords when lenient is true if (next is KeywordToken && (next.canConvertToIdentifier() || lenient)) { return (_advance() as KeywordToken).convertToIdentifier(); } if (next is KeywordToken) { message = '$message (got keyword ${reverseKeywords[next.type]})'; } return _consume(TokenType.identifier, message) as IdentifierToken; } /// Skips all tokens until it finds one with [type]. If [skipTarget] is true, /// that token will be skipped as well. /// /// When using `_synchronize(TokenType.semicolon, skipTarget: true)`, /// this will move the parser to the next statement, which can be useful for /// error recovery. void _synchronize(TokenType type, {bool skipTarget = false}) { if (skipTarget) { while (!_isAtEnd && _advance().type != type) {} } else { while (!_isAtEnd && !_check(type)) { _advance(); } } } /// Parses a statement without throwing when there's a parsing error. Statement safeStatement() { return _parseAsStatement(statement, requireSemicolon: false) ?? InvalidStatement(); } Statement _statementWithoutSemicolon() { if (_checkAny(const [ TokenType.$with, TokenType.select, TokenType.$values, TokenType.delete, TokenType.update, TokenType.insert, TokenType.replace, ])) { return _crud()!; } if (_check(TokenType.create)) { return _create()!; } if (_check(TokenType.begin)) { return _beginStatement(); } if (_checkAny(const [TokenType.commit, TokenType.end])) { return _commit(); } if (enableDriftExtensions) { if (_check(TokenType.import)) { return _import()!; } if (_check(TokenType.identifier) || _peek is KeywordToken) { return _declaredStatement()!; } } _error('Expected a sql statement to start here'); } Statement statement() { final first = _peek; final stmt = _statementWithoutSemicolon(); if (_matchOne(TokenType.semicolon)) { stmt.semicolon = _previous; } if (!_isAtEnd) { _error('Expected the statement to finish here'); } return stmt..setSpan(first, _previous); } DriftFile driftFile() { final first = _peek; final foundComponents = []; // (we try again if the last statement had a parsing error) // first, parse import statements for (var stmt = _parseAsStatement(_import); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_import)) { foundComponents.add(stmt); } // next, table declarations for (var stmt = _parseAsStatement(_create); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_create)) { foundComponents.add(stmt); } // finally, declared statements for (var stmt = _parseAsStatement(_declaredStatement); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_declaredStatement)) { foundComponents.add(stmt); } if (!_isAtEnd) { _error('Expected the file to end here.'); } foundComponents.removeWhere((c) => c == null); final file = DriftFile(foundComponents.cast()); if (foundComponents.isNotEmpty) { file.setSpan(first, _previous); } else { file.setSpan(first, first); // empty file } return file; } ImportStatement? _import() { if (_matchOne(TokenType.import)) { final importToken = _previous; final import = _consume(TokenType.stringLiteral, 'Expected import file as a string literal (single quoted)') as StringLiteralToken; return ImportStatement(import.value) ..importToken = importToken ..importString = import; } return null; } DeclaredStatement? _declaredStatement() { DeclaredStatementIdentifier identifier; if (_check(TokenType.identifier) || _peek is KeywordToken) { final name = _consumeIdentifier('Expected a name for a declared query', lenient: true); identifier = SimpleName(name.identifier)..identifier = name; } else if (_matchOne(TokenType.atSignVariable)) { final previous = _previous as AtSignVariableToken; identifier = SpecialStatementIdentifier(previous.name) ..nameToken = previous; } else { return null; } final parameters = []; if (_matchOne(TokenType.leftParen)) { do { parameters.add(_statementParameter()); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing parenthesis'); } String? as; if (_matchOne(TokenType.as)) { as = _consumeIdentifier('Expected a name of the result class').identifier; } final colon = _consume( TokenType.colon, 'Expected a colon (:) followed by a query. Imports and CREATE ' 'statements must appear before the first query.'); AstNode? stmt; if (_check(TokenType.begin)) { stmt = _transactionBlock(); } else { stmt = _crud(); } if (stmt == null) { _error( 'Expected a sql statement here (SELECT, UPDATE, INSERT or DELETE)'); } return DeclaredStatement( identifier, stmt, parameters: parameters, as: as, )..colon = colon; } StatementParameter _statementParameter() { final first = _peek; final isRequired = _matchOne(TokenType.required); final variable = _variableOrNull(); if (variable != null) { // Type hint for a variable Token? as; String? typeName; if (_matchOne(TokenType.as)) { as = _previous; final typeNameTokens = _typeName() ?? _error('Expected a type name here'); typeName = typeNameTokens.lexeme; } var orNull = false; if (_matchOne(TokenType.or)) { _consume(TokenType.$null, 'Expected NULL to finish OR NULL'); orNull = true; } return VariableTypeHint(variable, typeName, orNull: orNull, isRequired: isRequired) ..as = as ..setSpan(first, _previous); } else if (_matchOne(TokenType.dollarSignVariable)) { final placeholder = _previous as DollarSignVariableToken; _consume(TokenType.equal, 'Expected an equals sign here'); final defaultValue = expression(); return DartPlaceholderDefaultValue(placeholder.name, defaultValue) ..setSpan(placeholder, _previous) ..variableToken = placeholder; } else { _error('Expected a variable or a Dart placeholder here'); } } /// Invokes [parser], sets the appropriate source span and attaches a /// semicolon if one exists. T? _parseAsStatement(T? Function() parser, {bool requireSemicolon = true}) { _lastStmtHadParsingError = false; final first = _peek; T? result; try { result = parser(); if (result != null && requireSemicolon) { result.semicolon = _consume(TokenType.semicolon, 'Expected a semicolon after the statement ended'); result.setSpan(first, _previous); } } on ParsingError { _lastStmtHadParsingError = true; // the error is added to the list errors, so ignore. We skip after the // next semicolon to parse the next statement. _synchronize(TokenType.semicolon, skipTarget: true); if (result == null) return null; if (_matchOne(TokenType.semicolon)) { result.semicolon = _previous; } result.setSpan(first, _previous); } return result; } List _crudStatements() { final stmts = []; for (var stmt = _parseAsStatement(_crud); stmt != null || _lastStmtHadParsingError; stmt = _parseAsStatement(_crud)) { if (stmt != null) stmts.add(stmt); } return stmts; } /// Parses a block, which consists of statements between `BEGIN` and `END`. Block _consumeBlock() { final begin = _consume(TokenType.begin, 'Expected BEGIN'); final stmts = _crudStatements(); final end = _consume(TokenType.end, 'Expected END'); return Block(stmts) ..setSpan(begin, end) ..begin = begin ..end = end; } TransactionBlock _transactionBlock() { final first = _peek; final begin = _beginStatement(); final stmts = _crudStatements(); final end = _commit(); return TransactionBlock(begin: begin, innerStatements: stmts, commit: end) ..setSpan(first, _previous); } Expression expression() { return _or(); } /// Parses an expression of the form a b, where is in [types] and /// both a and b are expressions with a higher precedence parsed from /// [higherPrecedence]. Expression _parseSimpleBinary( List types, Expression Function() higherPrecedence) { var expression = higherPrecedence(); while (_match(types)) { final operator = _previous; final right = higherPrecedence(); expression = BinaryExpression(expression, operator, right) ..setSpan(expression.first!, _previous); } return expression; } Expression _or() => _parseSimpleBinary(const [TokenType.or], _and); Expression _and() => _parseSimpleBinary(const [TokenType.and], _in); Expression _in() { final left = _equals(); if (_checkWithNot(TokenType.$in)) { final not = _matchOne(TokenType.not); _matchOne(TokenType.$in); final inside = _variableOrNull() ?? _consumeTuple(orSubQuery: true); return InExpression(left: left, inside: inside, not: not) ..setSpan(left.first!, _previous); } return left; } /// Parses expressions with the "equals" precedence. This contains /// comparisons, "IS (NOT) IN" expressions, between expressions and "like" /// expressions. Expression _equals() { var expression = _comparison(); final first = expression.first; const ops = [ TokenType.equal, TokenType.doubleEqual, TokenType.exclamationEqual, TokenType.lessMore, TokenType.$is, ]; const stringOps = [ TokenType.like, TokenType.glob, TokenType.match, TokenType.regexp, ]; for (;;) { if (_checkWithNot(TokenType.between)) { final not = _matchOne(TokenType.not); _consume(TokenType.between, 'expected a BETWEEN'); final lower = _comparison(); _consume(TokenType.and, 'expected AND'); final upper = _comparison(); expression = BetweenExpression( not: not, check: expression, lower: lower, upper: upper) ..setSpan(first!, _previous); } else if (_match(ops)) { final operator = _previous; if (operator.type == TokenType.$is) { final not = _match(const [TokenType.not]); // special case: is not expression expression = IsExpression(not, expression, _comparison()) ..setSpan(first!, _previous); } else { expression = BinaryExpression(expression, operator, _comparison()) ..setSpan(first!, _previous); } } else if (_checkAnyWithNot(stringOps)) { final not = _matchOne(TokenType.not); _match(stringOps); // will consume, existence was verified with check final operator = _previous; final right = _comparison(); Expression? escape; if (_matchOne(TokenType.escape)) { escape = _comparison(); } expression = StringComparisonExpression( not: not, left: expression, operator: operator, right: right, escape: escape) ..setSpan(first!, _previous); } else { break; // no matching operator with this precedence was found } } return expression; } Expression _comparison() { return _parseSimpleBinary(_comparisonOperators, _binaryOperation); } Expression _binaryOperation() { return _parseSimpleBinary(_binaryOperators, _addition); } Expression _addition() { return _parseSimpleBinary(const [ TokenType.plus, TokenType.minus, ], _multiplication); } Expression _multiplication() { return _parseSimpleBinary(const [ TokenType.star, TokenType.slash, TokenType.percent, ], _concatenation); } Expression _concatenation() { return _parseSimpleBinary(const [ TokenType.doublePipe, TokenType.dashRangle, TokenType.dashRangleRangle ], _unary); } Expression _unary() { if (_match(const [ TokenType.minus, TokenType.plus, TokenType.tilde, TokenType.not, ])) { final operator = _previous; final expression = _unary(); return UnaryExpression(operator, expression) ..setSpan(operator, expression.last!); } else if (_matchOne(TokenType.exists)) { final existsToken = _previous; _consume( TokenType.leftParen, 'Expected opening parenthesis after EXISTS'); final selectStmt = _fullSelect() ?? _error('Expected a select statement'); _consume(TokenType.rightParen, 'Expected closing paranthesis to finish EXISTS expression'); return ExistsExpression(select: selectStmt) ..setSpan(existsToken, _previous); } return _postfix(); } Expression _postfix() { var expression = _prefix(); final firstToken = expression.first; // todo we don't currently parse "NOT NULL" (2 tokens) because of ambiguity // with NOT BETWEEN / NOT IN / ... expressions const matchedTokens = [ TokenType.collate, TokenType.notNull, TokenType.isNull ]; while (_match(matchedTokens)) { final operator = _previous; switch (operator.type) { case TokenType.collate: final collateOp = _previous; final collateFun = _consume(TokenType.identifier, 'Expected a collating sequence') as IdentifierToken; expression = CollateExpression( inner: expression, operator: collateOp, collateFunction: collateFun, ); break; case TokenType.isNull: expression = IsNullExpression(expression); break; case TokenType.notNull: expression = IsNullExpression(expression, true); break; default: // we checked with _match, this may never happen throw AssertionError(); } expression.setSpan(firstToken ?? operator, _previous); } return expression; } Expression _prefix() { if (_matchOne(TokenType.$case)) { final caseToken = _previous; final base = _check(TokenType.when) ? null : _primary(); final whens = []; Expression? $else; while (_matchOne(TokenType.when)) { final whenToken = _previous; final whenExpr = _or(); _consume(TokenType.then, 'Expected THEN'); final then = expression(); whens.add(WhenComponent(when: whenExpr, then: then) ..setSpan(whenToken, _previous)); } if (_matchOne(TokenType.$else)) { $else = expression(); } _consume(TokenType.end, 'Expected END to finish the case operator'); return CaseExpression(whens: whens, base: base, elseExpr: $else) ..setSpan(caseToken, _previous); } else if (_matchOne(TokenType.raise)) { final raiseToken = _previous; _consume(TokenType.leftParen, 'Expected a left parenthesis after RAISE'); RaiseKind kind; const tokenToRaiseKind = { TokenType.ignore: RaiseKind.ignore, TokenType.rollback: RaiseKind.rollback, TokenType.abort: RaiseKind.abort, TokenType.fail: RaiseKind.fail, }; if (_match(tokenToRaiseKind.keys)) { kind = tokenToRaiseKind[_previous.type]!; } else { _error('Expected IGNORE, ROLLBACK, ABORT or FAIL here'); } String? message; if (kind != RaiseKind.ignore) { _consume(TokenType.comma, 'Expected a comma here'); final messageToken = _consume(TokenType.stringLiteral, 'Expected an error message here') as StringLiteralToken; message = messageToken.value; } final end = _consume( TokenType.rightParen, 'Expected a right parenthesis to finish RAISE'); return RaiseExpression(kind, message)..setSpan(raiseToken, end); } return _primary(); } Literal? _literalOrNull() { final token = _peek; Literal? _parseInner() { if (_check(TokenType.numberLiteral)) { return _numericLiteral(); } if (_matchOne(TokenType.stringLiteral)) { return StringLiteral(token as StringLiteralToken); } if (_matchOne(TokenType.$null)) { return NullLiteral(token); } if (_matchOne(TokenType.$true)) { return BooleanLiteral.withTrue(token); } if (_matchOne(TokenType.$false)) { return BooleanLiteral.withFalse(token); } const timeLiterals = { TokenType.currentTime: TimeConstantKind.currentTime, TokenType.currentDate: TimeConstantKind.currentDate, TokenType.currentTimestamp: TimeConstantKind.currentTimestamp, }; if (_match(timeLiterals.keys)) { final token = _previous; return TimeConstantLiteral(timeLiterals[token.type]!, token); } return null; } final literal = _parseInner(); literal?.setSpan(token, token); return literal; } NumericLiteral _numericLiteral() { final number = _consume(TokenType.numberLiteral, 'Expected a number here') as NumericToken; return NumericLiteral(number.parsedNumber, number)..setSpan(number, number); } Expression _primary() { final literal = _literalOrNull(); if (literal != null) return literal; final variable = _variableOrNull(); if (variable != null) return variable; if (_matchOne(TokenType.leftParen)) { final left = _previous; final selectStmt = _fullSelect(); // returns null if there's no select if (selectStmt != null) { _consume(TokenType.rightParen, 'Expected a closing bracket'); return SubQuery(select: selectStmt)..setSpan(left, _previous); } else { final expr = expression(); if (_matchOne(TokenType.comma)) { // It's a row value! final expressions = [expr]; do { expressions.add(expression()); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected a closing bracket'); return Tuple(expressions: expressions, usedAsRowValue: true) ..setSpan(left, _previous); } _consume(TokenType.rightParen, 'Expected a closing bracket'); return Parentheses(expr) ..openingLeft = left ..closingRight = _previous ..setSpan(left, _previous); } } else if (_matchOne(TokenType.dollarSignVariable)) { if (enableDriftExtensions) { final typedToken = _previous as DollarSignVariableToken; return DartExpressionPlaceholder(name: typedToken.name) ..token = typedToken ..setSpan(_previous, _previous); } } else if (_matchOne(TokenType.cast)) { final first = _previous; _consume(TokenType.leftParen, 'Expected opening parenthesis after CAST'); final operand = expression(); _consume(TokenType.as, 'Expected AS operator here'); final type = _typeName()!; final typeName = type.lexeme; _consume(TokenType.rightParen, 'Expected closing bracket here'); return CastExpression(operand, typeName)..setSpan(first, _previous); } else if (_checkIdentifier()) { return _referenceOrFunctionCall(); } if (_peek is KeywordToken) { _error('Could not parse this expression. Note: This is a reserved ' 'keyword, you can escape it in double ticks'); } else { _error('Could not parse this expression'); } } Expression _referenceOrFunctionCall() { final first = _consumeIdentifier( 'This error message should never be displayed. Please report.'); // An expression starting with an identifier could be three things: // - a simple reference: "foo" // - a reference with a table: "foo.bar" // - a reference with a table and a schema: "foo.bar.baz" // - a function call: "foo()" if (_matchOne(TokenType.dot)) { // Ok, we're down to two here. it's either a table or a schema ref final second = _consumeIdentifier('Expected a column or table name here', lenient: true); if (_matchOne(TokenType.dot)) { // Three identifiers, that's a schema reference final third = _consumeIdentifier('Expected a column name here', lenient: true); return Reference( schemaName: first.identifier, entityName: second.identifier, columnName: third.identifier, )..setSpan(first, third); } else { // Two identifiers only, so we have a table-based reference return Reference( entityName: first.identifier, columnName: second.identifier, )..setSpan(first, second); } } else if (_matchOne(TokenType.leftParen)) { // We have something like "foo(" -> that's a function! final parameters = _functionParameters(); final rightParen = _consume( TokenType.rightParen, 'Expected closing bracket after argument list'); if (_peek.type == TokenType.filter || _peek.type == TokenType.over) { return _aggregate(first, parameters); } return FunctionExpression(name: first.identifier, parameters: parameters) ..setSpan(first, rightParen); } else { // Ok, just a regular reference then return Reference(columnName: first.identifier)..setSpan(first, first); } } Variable? _variableOrNull() { if (_matchOne(TokenType.questionMarkVariable)) { return NumberedVariable(_previous as QuestionMarkVariableToken) ..setSpan(_previous, _previous); } else if (_matchOne(TokenType.colonVariable)) { return ColonNamedVariable(_previous as ColonVariableToken) ..setSpan(_previous, _previous); } return null; } /// Parses function parameters, without the surrounding parentheses. FunctionParameters _functionParameters() { if (_matchOne(TokenType.star)) { return StarFunctionParameter() ..starToken = _previous ..setSpan(_previous, _previous); } if (_check(TokenType.rightParen)) { // nothing between the brackets -> empty parameter list. We mark it as // synthetic because it has an empty span in the file return ExprFunctionParameters(parameters: const [])..synthetic = true; } final distinct = _matchOne(TokenType.distinct); final parameters = []; final first = _peek; do { parameters.add(expression()); } while (_matchOne(TokenType.comma)); return ExprFunctionParameters(distinct: distinct, parameters: parameters) ..setSpan(first, _previous); } AggregateFunctionInvocation _aggregate( IdentifierToken name, FunctionParameters params) { Expression? filter; // https://www.sqlite.org/syntax/filter.html (it's optional) if (_matchOne(TokenType.filter)) { _consume(TokenType.leftParen, 'Expected opening parenthesis after filter statement'); _consume(TokenType.where, 'Expected WHERE clause'); filter = expression(); _consume(TokenType.rightParen, 'Expecteded closing parenthes'); } if (_matchOne(TokenType.over)) { String? windowName; WindowDefinition? window; if (_matchOne(TokenType.identifier)) { windowName = (_previous as IdentifierToken).identifier; } else { window = _windowDefinition(); } return WindowFunctionInvocation( function: name, parameters: params, filter: filter, windowDefinition: window, windowName: windowName, )..setSpan(name, _previous); } else { return AggregateFunctionInvocation( function: name, parameters: params, filter: filter, )..setSpan(name, _previous); } } /// Parses a [Tuple]. If [orSubQuery] is set (defaults to false), a [SubQuery] /// (in brackets) will be accepted as well. Expression _consumeTuple({bool orSubQuery = false}) { final firstToken = _consume(TokenType.leftParen, 'Expected opening parenthesis for tuple'); final expressions = []; // if desired, attempt to parse select statement final subQuery = orSubQuery ? _fullSelect() : null; if (subQuery == null) { // no sub query found. read expressions that form the tuple. // tuples can be empty `()`, so only start parsing values when it's not if (_peek.type != TokenType.rightParen) { do { expressions.add(expression()); } while (_matchOne(TokenType.comma)); } _consume( TokenType.rightParen, 'Expected right parenthesis to close tuple'); return Tuple(expressions: expressions)..setSpan(firstToken, _previous); } else { _consume(TokenType.rightParen, 'Expected right parenthesis to finish subquery'); return SubQuery(select: subQuery)..setSpan(firstToken, _previous); } } BeginTransactionStatement _beginStatement() { final begin = _consume(TokenType.begin); Token? modeToken; var mode = TransactionMode.none; if (_match( const [TokenType.deferred, TokenType.immediate, TokenType.exclusive])) { modeToken = _previous; switch (modeToken.type) { case TokenType.deferred: mode = TransactionMode.deferred; break; case TokenType.immediate: mode = TransactionMode.immediate; break; case TokenType.exclusive: mode = TransactionMode.exclusive; break; default: throw AssertionError('unreachable'); } } Token? transaction; if (_matchOne(TokenType.transaction)) { transaction = _previous; } return BeginTransactionStatement(mode) ..setSpan(begin, _previous) ..begin = begin ..modeToken = modeToken ..transaction = transaction; } CommitStatement _commit() { Token commitOrEnd; if (_match(const [TokenType.commit, TokenType.end])) { commitOrEnd = _previous; } else { _error('Expected COMMIT or END here'); } Token? transaction; if (_matchOne(TokenType.transaction)) { transaction = _previous; } return CommitStatement() ..setSpan(commitOrEnd, _previous) ..commitOrEnd = commitOrEnd ..transaction = transaction; } CrudStatement? _crud() { final withClause = _withClause(); if (_check(TokenType.select) || _check(TokenType.$values)) { return select(withClause: withClause); } else if (_check(TokenType.delete)) { return _deleteStmt(withClause); } else if (_check(TokenType.update)) { return _update(withClause); } else if (_check(TokenType.insert) || _check(TokenType.replace)) { return _insertStmt(withClause); } // A WITH clause without a following select, insert, delete or update // is invalid! if (withClause != null) { _error('Expected a SELECT, INSERT, UPDATE or DELETE statement to ' 'follow this WITH clause.'); } return null; } WithClause? _withClause() { if (!_matchOne(TokenType.$with)) return null; final withToken = _previous; final recursive = _matchOne(TokenType.recursive); final recursiveToken = recursive ? _previous : null; final ctes = []; do { final name = _consumeIdentifier('Expected name for common table'); List? columnNames; // can optionally declare the column names in (foo, bar, baz) syntax if (_matchOne(TokenType.leftParen)) { columnNames = []; do { final identifier = _consumeIdentifier('Expected column name'); columnNames.add(identifier.identifier); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing bracket after column names'); } final asToken = _consume(TokenType.as, 'Expected AS'); MaterializationHint? hint; Token? not, materialized; if (_matchOne(TokenType.not)) { not = _previous; materialized = _consume(TokenType.materialized); hint = MaterializationHint.notMaterialized; } else if (_matchOne(TokenType.materialized)) { materialized = _previous; hint = MaterializationHint.materialized; } const msg = 'Expected select statement in brackets'; _consume(TokenType.leftParen, msg); final selectStmt = select() ?? _error(msg); _consume(TokenType.rightParen, msg); ctes.add(CommonTableExpression( cteTableName: name.identifier, materializationHint: hint, columnNames: columnNames, as: selectStmt, ) ..setSpan(name, _previous) ..asToken = asToken ..tableNameToken = name ..not = not ..materialized = materialized); } while (_matchOne(TokenType.comma)); return WithClause( recursive: recursive, ctes: ctes, ) ..setSpan(withToken, _previous) ..recursiveToken = recursiveToken ..withToken = withToken; } /// Parses a select statement as defined in [the sqlite documentation][s-d], /// which means that compound selects and a with clause is supported. /// /// [s-d]: https://sqlite.org/syntax/select-stmt.html BaseSelectStatement? _fullSelect() { final clause = _withClause(); return select(withClause: clause); } /// Parses a [BaseSelectStatement], which is either a [SelectStatement] or a /// [CompoundSelectStatement]. If [noCompound] is set to true, the parser will /// only attempt to parse a [SelectStatement]. /// /// This method doesn't parse WITH clauses, most users would probably want to /// use [_fullSelect] instead. /// /// See also: /// https://www.sqlite.org/lang_select.html BaseSelectStatement? select({bool? noCompound, WithClause? withClause}) { if (noCompound == true) { return _selectNoCompound(withClause); } else { final firstTokenOfBase = _peek; final first = _selectNoCompound(withClause); if (first == null) { // _selectNoCompound returns null if there's no select statement at the // current position. That's fine if we didn't encounter an with clause // already if (withClause != null) { _error('Expected a SELECT statement to follow the WITH clause here'); } return null; } final parts = []; for (;;) { final part = _compoundSelectPart(); if (part != null) { parts.add(part); } else { break; } } if (parts.isEmpty) { // no compound parts, just return the simple select statement. return first; } else { // remove with clause from base select, it belongs to the compound // select. first.withClause = null; first.first = firstTokenOfBase; return CompoundSelectStatement( withClause: withClause, base: first, additional: parts, )..setSpan(withClause?.first ?? first.first!, _previous); } } } SelectStatementNoCompound? _selectNoCompound([WithClause? withClause]) { if (_peek.type == TokenType.$values) return _valuesSelect(withClause); if (!_match(const [TokenType.select])) return null; final selectToken = _previous; var distinct = false; if (_matchOne(TokenType.distinct)) { distinct = true; } else if (_matchOne(TokenType.all)) { distinct = false; } final resultColumns = _resultColumns(); final from = _from(); final where = _whereOrNull(); final groupBy = _groupBy(); final windowDecls = _windowDeclarations(); final orderBy = _orderBy(); final limit = _limit(); final first = withClause?.first ?? selectToken; return SelectStatement( withClause: withClause, distinct: distinct, columns: resultColumns, from: from, where: where, groupBy: groupBy, windowDeclarations: windowDecls, orderBy: orderBy, limit: limit, )..setSpan(first, _previous); } ValuesSelectStatement? _valuesSelect([WithClause? withClause]) { if (!_matchOne(TokenType.$values)) return null; final firstToken = _previous; final tuples = []; do { tuples.add(_consumeTuple() as Tuple); } while (_matchOne(TokenType.comma)); return ValuesSelectStatement(tuples, withClause: withClause) ..setSpan(firstToken, _previous); } CompoundSelectPart? _compoundSelectPart() { if (_match( const [TokenType.union, TokenType.intersect, TokenType.except])) { final firstModeToken = _previous; var mode = const { TokenType.union: CompoundSelectMode.union, TokenType.intersect: CompoundSelectMode.intersect, TokenType.except: CompoundSelectMode.except, }[firstModeToken.type]; Token? allToken; if (firstModeToken.type == TokenType.union && _matchOne(TokenType.all)) { allToken = _previous; mode = CompoundSelectMode.unionAll; } final select = _selectNoCompound(); if (select == null) { _error('Expected a select statement here!'); } return CompoundSelectPart( mode: mode!, select: select, ) ..firstModeToken = firstModeToken ..allToken = allToken ..setSpan(firstModeToken, _previous); } return null; } /// Returns an identifier followed after an optional "AS" token in sql. /// Returns null if there is IdentifierToken? _as() { if (_match(const [TokenType.as])) { return _consume(TokenType.identifier, 'Expected an identifier') as IdentifierToken; } else if (_match(const [TokenType.identifier])) { return _previous as IdentifierToken; } else { return null; } } Queryable? _from() { if (!_matchOne(TokenType.from)) return null; // Can either be a list of or a join. Joins also start // with a TableOrSubquery, so let's first parse that. final start = _tableOrSubquery(); // parse join, if there is one return _joinClause(start) ?? start; } TableOrSubquery _tableOrSubquery() { // this is what we're parsing: https://www.sqlite.org/syntax/table-or-subquery.html // we currently only support regular tables, table functions and nested // selects final tableRef = _tableReferenceOrNull(); if (tableRef != null) { // this is a bit hacky. If the table reference only consists of one // identifer and it's followed by a (, it's a table-valued function if (tableRef.as == null && _matchOne(TokenType.leftParen)) { final params = _functionParameters(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); final alias = _as(); return TableValuedFunction(tableRef.tableName, params, as: alias?.identifier) ..setSpan(tableRef.first!, _previous); } return tableRef; } else if (_matchOne(TokenType.leftParen)) { final first = _previous; 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) ..setSpan(first, _previous); } _error('Expected a table name or a nested select statement'); } TableReference? _tableReferenceOrNull() { _suggestHint(const TableNameDescription()); if (_check(TokenType.identifier)) return _tableReference(); return null; } JoinClause? _joinClause(TableOrSubquery start) { var operator = _parseJoinOperator(); if (operator == null) { return null; } final joins = []; while (operator != null) { final first = _peekNext; final subquery = _tableOrSubquery(); final constraint = _joinConstraint(); JoinOperator resolvedOperator; if (operator.contains(TokenType.left)) { resolvedOperator = operator.contains(TokenType.outer) ? JoinOperator.leftOuter : JoinOperator.left; } else if (operator.contains(TokenType.inner)) { resolvedOperator = JoinOperator.inner; } else if (operator.contains(TokenType.cross)) { resolvedOperator = JoinOperator.cross; } else if (operator.contains(TokenType.comma)) { resolvedOperator = JoinOperator.comma; } else { resolvedOperator = JoinOperator.none; } joins.add(Join( natural: operator.contains(TokenType.natural), operator: resolvedOperator, query: subquery, constraint: constraint, )..setSpan(first, _previous)); // parse the next operator, if there is more than one join operator = _parseJoinOperator(); } return JoinClause(primary: start, joins: joins) ..setSpan(start.first!, _previous); } /// Parses https://www.sqlite.org/syntax/join-operator.html List? _parseJoinOperator() { const _startJoinOperators = [ TokenType.natural, TokenType.left, TokenType.inner, TokenType.cross, TokenType.join, TokenType.comma, ]; if (_match(_startJoinOperators)) { final operators = [_previous.type]; if (_previous.type == TokenType.join || _previous.type == TokenType.comma) { // just join or comma, 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); } else { return null; } } /// Parses a where clause if there is one at the current position Expression? _whereOrNull() { if (_matchOne(TokenType.where)) { return expression(); } return null; } GroupBy? _groupBy() { if (_matchOne(TokenType.group)) { final groupToken = _previous; _consume(TokenType.by, 'Expected a "BY"'); final by = []; Expression? having; do { by.add(expression()); } while (_matchOne(TokenType.comma)); if (_matchOne(TokenType.having)) { having = expression(); } return GroupBy(by: by, having: having)..setSpan(groupToken, _previous); } return null; } List _windowDeclarations() { final declarations = []; if (_matchOne(TokenType.window)) { do { final name = _consumeIdentifier('Expected a name for the window'); _consume(TokenType.as, 'Expected AS between the window name and its definition'); final window = _windowDefinition(); declarations.add(NamedWindowDeclaration(name.identifier, window)); } while (_matchOne(TokenType.comma)); } return declarations; } OrderByBase? _orderBy() { if (_matchOne(TokenType.order)) { final orderToken = _previous; _consume(TokenType.by, 'Expected "BY" after "ORDER" token'); final terms = []; do { terms.add(_orderingTerm()); } while (_matchOne(TokenType.comma)); // If we only hit a single ordering term and that term is a Dart // placeholder, we can upgrade that term to a full order by placeholder. // This gives users more control at runtime (they can specify multiple // terms). if (terms.length == 1 && terms.single is DartOrderingTermPlaceholder) { final termPlaceholder = terms.single as DartOrderingTermPlaceholder; return DartOrderByPlaceholder(name: termPlaceholder.name) ..setSpan(orderToken, termPlaceholder.last!); } return OrderBy(terms: terms)..setSpan(orderToken, _previous); } return null; } OrderingTermBase _orderingTerm() { final expr = expression(); final mode = _orderingModeOrNull(); OrderingBehaviorForNulls? nulls; if (_matchOne(TokenType.nulls)) { if (_matchOne(TokenType.first)) { nulls = OrderingBehaviorForNulls.first; } else if (_matchOne(TokenType.last)) { nulls = OrderingBehaviorForNulls.last; } else { _error('Expected FIRST or LAST here'); } } // if there is nothing (asc/desc, nulls first/last) after a Dart // placeholder, we can upgrade the expression to an ordering term // placeholder and let users define the mode at runtime. if (mode == null && nulls == null && expr is DartExpressionPlaceholder) { return DartOrderingTermPlaceholder(name: expr.name) ..setSpan(expr.first!, expr.last!); } return OrderingTerm(expression: expr, orderingMode: mode, nulls: nulls) ..setSpan(expr.first!, _previous); } OrderingMode? _orderingModeOrNull() { if (_match(const [TokenType.asc, TokenType.desc])) { final mode = _previous.type == TokenType.asc ? OrderingMode.ascending : OrderingMode.descending; return mode; } return null; } /// Parses a [Limit] clause, or returns null if there is no limit token after /// the current position. LimitBase? _limit() { if (!_matchOne(TokenType.limit)) return null; final limitToken = _previous; // Unintuitive, it's "$amount OFFSET $offset", but "$offset, $amount" // the order changes between the separator tokens. final first = expression(); if (_matchOne(TokenType.comma)) { final separator = _previous; final count = expression(); return Limit(count: count, offsetSeparator: separator, offset: first) ..setSpan(limitToken, _previous); } else if (_matchOne(TokenType.offset)) { final separator = _previous; final offset = expression(); return Limit(count: first, offsetSeparator: separator, offset: offset) ..setSpan(limitToken, _previous); } else { // no offset or comma was parsed (so just LIMIT $expr). In that case, we // want to provide additional flexibility to the user by interpreting the // expression as a whole limit clause. if (first is DartExpressionPlaceholder) { return DartLimitPlaceholder(name: first.name) ..setSpan(limitToken, _previous); } return Limit(count: first)..setSpan(limitToken, _previous); } } DeleteStatement? _deleteStmt([WithClause? withClause]) { if (!_matchOne(TokenType.delete)) return null; final deleteToken = _previous; _consume(TokenType.from, 'Expected a FROM here'); final table = _tableReference(); final where = _whereOrNull(); final returning = _returningOrNull(); return DeleteStatement( withClause: withClause, from: table, where: where, returning: returning, )..setSpan(withClause?.first ?? deleteToken, _previous); } UpdateStatement? _update([WithClause? withClause]) { if (!_matchOne(TokenType.update)) return null; final updateToken = _previous; FailureMode? failureMode; if (_matchOne(TokenType.or)) { failureMode = UpdateStatement.failureModeFromToken(_advance().type); } final table = _tableReference(); _consume(TokenType.set, 'Expected SET after the table name'); final set = _setComponents(); final from = _from(); final where = _whereOrNull(); final returning = _returningOrNull(); return UpdateStatement( withClause: withClause, or: failureMode, table: table, set: set, from: from, where: where, returning: returning, )..setSpan(withClause?.first ?? updateToken, _previous); } List _setComponents() { final set = []; do { final columnName = _consume(TokenType.identifier, 'Expected a column name to set') as IdentifierToken; final reference = Reference(columnName: columnName.identifier) ..setSpan(columnName, columnName); _consume(TokenType.equal, 'Expected = after the column name'); final expr = expression(); set.add(SetComponent(column: reference, expression: expr) ..setSpan(columnName, _previous)); } while (_matchOne(TokenType.comma)); return set; } InsertStatement? _insertStmt([WithClause? withClause]) { if (!_match(const [TokenType.insert, TokenType.replace])) return null; final firstToken = _previous; InsertMode? insertMode; if (_previous.type == TokenType.insert) { // insert modes can have a failure clause (INSERT OR xxx) if (_matchOne(TokenType.or)) { const tokensToModes = { TokenType.replace: InsertMode.insertOrReplace, TokenType.rollback: InsertMode.insertOrRollback, TokenType.abort: InsertMode.insertOrAbort, TokenType.fail: InsertMode.insertOrFail, TokenType.ignore: InsertMode.insertOrIgnore }; if (_match(tokensToModes.keys)) { insertMode = tokensToModes[_previous.type]; } else { _error('After the INSERT OR, expected an insert mode ' '(REPLACE, ROLLBACK, etc.)'); } } else { insertMode = InsertMode.insert; } } else { // if it wasn't an insert, it must have been a replace insertMode = InsertMode.replace; } assert(insertMode != null); _consume(TokenType.into, 'Expected INSERT INTO'); final table = _tableReference(); final targetColumns = []; if (_matchOne(TokenType.leftParen)) { do { final columnRef = _consumeIdentifier('Expected a column'); targetColumns.add(Reference(columnName: columnRef.identifier) ..setSpan(columnRef, columnRef)); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected clpsing parenthesis after column list'); } final source = _insertSource(); final upsert = []; while (_check(TokenType.on)) { upsert.add(_upsertClauseEntry()); } final returning = _returningOrNull(); return InsertStatement( withClause: withClause, mode: insertMode!, table: table, targetColumns: targetColumns, source: source, upsert: upsert.isEmpty ? null : (UpsertClause(upsert) ..setSpan(upsert.first.first!, upsert.last.last!)), returning: returning, )..setSpan(withClause?.first ?? firstToken, _previous); } InsertSource _insertSource() { if (_matchOne(TokenType.$values)) { final first = _previous; final values = []; do { // it will be a tuple, we don't turn on "orSubQuery" values.add(_consumeTuple() as Tuple); } while (_matchOne(TokenType.comma)); return ValuesSource(values)..setSpan(first, _previous); } else if (_matchOne(TokenType.$default)) { final first = _previous; _consume(TokenType.$values, 'Expected DEFAULT VALUES'); return DefaultValues()..setSpan(first, _previous); } else if (enableDriftExtensions && _matchOne(TokenType.dollarSignVariable)) { final token = _previous as DollarSignVariableToken; return DartInsertablePlaceholder(name: token.name) ..token = token ..setSpan(token, token); } else { final first = _previous; return SelectInsertSource( _fullSelect() ?? _error('Expeced a select statement'), )..setSpan(first, _previous); } } UpsertClauseEntry _upsertClauseEntry() { final first = _consume(TokenType.on); _consume(TokenType.conflict, 'Expected CONFLICT keyword for upsert clause'); List? indexedColumns; Expression? where; if (_matchOne(TokenType.leftParen)) { indexedColumns = _indexedColumns(); _consume(TokenType.rightParen, 'Expected closing paren here'); if (_matchOne(TokenType.where)) { where = expression(); } } _consume(TokenType.$do, 'Expected DO, followed by the action (NOTHING or UPDATE SET)'); late UpsertAction action; if (_matchOne(TokenType.nothing)) { action = DoNothing()..setSpan(_previous, _previous); } else if (_check(TokenType.update)) { action = _doUpdate(); } return UpsertClauseEntry( onColumns: indexedColumns, where: where, action: action, )..setSpan(first, _previous); } DoUpdate _doUpdate() { _consume(TokenType.update, 'Expected UPDATE SET keyword here'); final first = _previous; _consume(TokenType.set, 'Expected UPDATE SET keyword here'); final set = _setComponents(); Expression? where; if (_matchOne(TokenType.where)) { where = expression(); } return DoUpdate(set, where: where)..setSpan(first, _previous); } /// https://www.sqlite.org/syntax/window-defn.html WindowDefinition _windowDefinition() { _consume(TokenType.leftParen, 'Expected opening parenthesis'); final leftParen = _previous; String? baseWindowName; OrderByBase? orderBy; final partitionBy = []; if (_matchOne(TokenType.identifier)) { baseWindowName = (_previous as IdentifierToken).identifier; } if (_matchOne(TokenType.partition)) { _consume(TokenType.by, 'Expected PARTITION BY'); do { partitionBy.add(expression()); } while (_matchOne(TokenType.comma)); } if (_peek.type == TokenType.order) { orderBy = _orderBy(); } final spec = _frameSpec(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); return WindowDefinition( baseWindowName: baseWindowName, partitionBy: partitionBy, orderBy: orderBy, frameSpec: spec ?? (FrameSpec()..synthetic = true), )..setSpan(leftParen, _previous); } /// https://www.sqlite.org/syntax/frame-spec.html FrameSpec? _frameSpec() { if (!_match(const [TokenType.range, TokenType.rows, TokenType.groups])) { return null; } final typeToken = _previous; final frameType = const { TokenType.range: FrameType.range, TokenType.rows: FrameType.rows, TokenType.groups: FrameType.groups }[typeToken.type]; FrameBoundary start, end; // if there is no between token, we just read the start boundary and set the // end to currentRow. See the link in the docs if (_matchOne(TokenType.between)) { start = _frameBoundary(isStartBounds: true, parseExprFollowing: true); _consume(TokenType.and, 'Expected AND followed by the ending boundary'); end = _frameBoundary(isStartBounds: false, parseExprFollowing: true); } else { // FOLLOWING is not supported in the short-hand syntax start = _frameBoundary(isStartBounds: true, parseExprFollowing: false); end = FrameBoundary.currentRow(); } var exclude = ExcludeMode.noOthers; if (_matchOne(TokenType.exclude)) { if (_matchOne(TokenType.ties)) { exclude = ExcludeMode.ties; } else if (_matchOne(TokenType.group)) { exclude = ExcludeMode.group; } else if (_matchOne(TokenType.current)) { _consume(TokenType.row, 'Expected EXCLUDE CURRENT ROW'); exclude = ExcludeMode.currentRow; } else if (_matchOne(TokenType.no)) { _consume(TokenType.others, 'Expected EXCLUDE NO OTHERS'); exclude = ExcludeMode.noOthers; } } return FrameSpec( type: frameType, excludeMode: exclude, start: start, end: end, )..setSpan(typeToken, _previous); } FrameBoundary _frameBoundary( {bool isStartBounds = true, bool parseExprFollowing = true}) { // the CURRENT ROW boundary is supported for all modes if (_matchOne(TokenType.current)) { _consume(TokenType.row, 'Expected ROW to finish CURRENT ROW boundary'); return FrameBoundary.currentRow(); } if (_matchOne(TokenType.unbounded)) { // if this is a start boundary, only UNBOUNDED PRECEDING makes sense. // Otherwise, only UNBOUNDED FOLLOWING makes sense if (isStartBounds) { _consume(TokenType.preceding, 'Expected UNBOUNDED PRECEDING'); return FrameBoundary.unboundedPreceding(); } else { _consume(TokenType.following, 'Expected UNBOUNDED FOLLOWING'); return FrameBoundary.unboundedFollowing(); } } // ok, not unbounded or CURRENT ROW. It must be PRECEDING|FOLLOWING // then final amount = expression(); if (parseExprFollowing && _matchOne(TokenType.following)) { return FrameBoundary.following(amount); } else if (_matchOne(TokenType.preceding)) { return FrameBoundary.preceding(amount); } _error('Expected either PRECEDING or FOLLOWING here'); } Returning? _returningOrNull() { if (!_matchOne(TokenType.returning)) return null; final previous = _previous; return Returning(_resultColumns())..setSpan(previous, _previous); } List _resultColumns() { final columns = []; do { columns.add(_resultColumn()); } while (_matchOne(TokenType.comma)); return columns; } /// Parses a [ResultColumn] or throws if none is found. /// https://www.sqlite.org/syntax/result-column.html ResultColumn _resultColumn() { if (_matchOne(TokenType.star)) { return StarResultColumn(null)..setSpan(_previous, _previous); } final positionBefore = _current; if (_matchOne(TokenType.identifier)) { // two options. the identifier could be followed by ".*", in which case // we have a star result column. If it's followed by anything else, it can // still refer to a column in a table as part of a expression // result column final identifier = _previous as IdentifierToken; if (_matchOne(TokenType.dot)) { if (_matchOne(TokenType.star)) { return StarResultColumn(identifier.identifier) ..setSpan(identifier, _previous); } else if (enableDriftExtensions && _matchOne(TokenType.doubleStar)) { final as = _as(); return NestedStarResultColumn( tableName: identifier.identifier, as: as?.identifier, )..setSpan(identifier, _previous); } } // not a star result column. go back and parse the expression. // todo this is a bit unorthodox. is there a better way to parse the // expression from before? _current = positionBefore; } // parsing for the nested query column if (enableDriftExtensions && _matchOne(TokenType.list)) { final list = _previous; _consume( TokenType.leftParen, 'Expected opening parenthesis after LIST', ); final statement = _fullSelect(); if (statement == null || statement is! SelectStatement) { _error('Expected a select statement here'); } _consume( TokenType.rightParen, 'Expected closing parenthesis to finish LIST expression', ); final as = _as(); return NestedQueryColumn(select: statement, as: as?.identifier) ..setSpan(list, _previous); } final tokenBefore = _peek; final expr = expression(); final as = _as(); return ExpressionResultColumn(expression: expr, as: as?.identifier) ..setSpan(tokenBefore, _previous); } SchemaStatement? _create() { if (!_matchOne(TokenType.create)) return null; if (_check(TokenType.table) || _check(TokenType.virtual)) { return _createTable(); } else if (_check(TokenType.trigger)) { return _createTrigger(); } else if (_check(TokenType.unique) || _check(TokenType.$index)) { return _createIndex(); } else if (_check(TokenType.view)) { return _createView(); } return null; } /// Parses a `CREATE TABLE` statement, assuming that the `CREATE` token has /// already been matched. TableInducingStatement _createTable() { final first = _previous; assert(first.type == TokenType.create); final virtual = _matchOne(TokenType.virtual); _consume(TokenType.table, 'Expected TABLE keyword here'); final ifNotExists = _ifNotExists(); final tableIdentifier = _consumeIdentifier('Expected a table name'); if (virtual) { return _virtualTable(first, ifNotExists, tableIdentifier); } // we don't currently support CREATE TABLE x AS SELECT ... statements final leftParen = _consume( TokenType.leftParen, 'Expected opening parenthesis to list columns'); final columns = []; final tableConstraints = []; // the columns must come before the table constraints! var encounteredTableConstraint = false; do { try { final tableConstraint = _tableConstraintOrNull(); if (tableConstraint != null) { encounteredTableConstraint = true; tableConstraints.add(tableConstraint); } else { if (encounteredTableConstraint) { _error('Expected another table constraint'); } else { columns.add(_columnDefinition()); } } } on ParsingError { // if we're at the closing bracket, don't try to parse another column if (_check(TokenType.rightParen)) break; // error while parsing a column definition or table constraint. We try // to recover to the next comma. _synchronize(TokenType.comma); if (_check(TokenType.rightParen)) break; } } while (_matchOne(TokenType.comma)); final rightParen = _consume(TokenType.rightParen, 'Expected closing parenthesis'); var withoutRowId = false; var isStrict = false; Token? strict; // Parses a `WITHOUT ROWID` or a `STRICT` keyword. Returns if either such // option has been parsed. bool tableOptions() { if (_matchOne(TokenType.strict)) { isStrict = true; strict = _previous; return true; } else if (_matchOne(TokenType.without)) { _consume(TokenType.rowid, 'Expected ROWID to complete the WITHOUT ROWID part'); withoutRowId = true; return true; } return false; } // Table options can be seperated by comma, but they're not required either. if (tableOptions()) { while (_matchOne(TokenType.comma)) { if (!tableOptions()) { _error('Expected WITHOUT ROWID or STRICT here!'); } } } while (_check(TokenType.without) || _check(TokenType.strict)) { if (_matchOne(TokenType.without)) { } else { // Matched a strict keyword isStrict = true; _advance(); assert(_previous.type == TokenType.strict); } } final overriddenName = _driftTableName(); return CreateTableStatement( ifNotExists: ifNotExists, tableName: tableIdentifier.identifier, withoutRowId: withoutRowId, columns: columns, tableConstraints: tableConstraints, isStrict: isStrict, driftTableName: overriddenName, ) ..setSpan(first, _previous) ..openingBracket = leftParen ..tableNameToken = tableIdentifier ..closingBracket = rightParen ..strict = strict; } /// Parses a `CREATE VIRTUAL TABLE` statement, after the `CREATE VIRTUAL TABLE /// ` tokens have already been read. CreateVirtualTableStatement _virtualTable( Token first, bool ifNotExists, IdentifierToken nameToken) { _consume(TokenType.using, 'Expected USING for virtual table declaration'); final moduleName = _consumeIdentifier('Expected a module name'); final args = []; if (_matchOne(TokenType.leftParen)) { // args can be just about anything, so we accept any token until the right // parenthesis closing it of. Token? currentStart; var levelOfParens = 0; void addCurrent() { if (currentStart == null) { _error('Expected at least one token for the previous argument'); } else { args.add(currentStart!.span.expand(_previous.span)); currentStart = null; } } for (;;) { // begin reading a single argument, which is stopped by a comma or // maybe with a ), if the current depth is one while (_peek.type != TokenType.rightParen && _peek.type != TokenType.comma) { _advance(); if (_previous.type == TokenType.leftParen) { levelOfParens++; } currentStart ??= _previous; } // if we just read the last ) of the argument list, finish. Otherwise // just handle the ) and continue reading the same argument if (_peek.type == TokenType.rightParen) { levelOfParens--; if (levelOfParens < 0) { addCurrent(); _advance(); // consume the rightParen break; } else { _advance(); // add the rightParen to the current argument continue; } } // finished while loop above, but not with a ), so it must be a comma // that finishes the current argument assert(_peek.type == TokenType.comma); addCurrent(); _advance(); // consume the comma } } final driftTableName = _driftTableName(); return CreateVirtualTableStatement( ifNotExists: ifNotExists, tableName: nameToken.identifier, moduleName: moduleName.identifier, arguments: args, driftTableName: driftTableName, ) ..setSpan(first, _previous) ..tableNameToken = nameToken ..moduleNameToken = moduleName; } DriftTableName? _driftTableName({bool supportAs = true}) { final types = supportAs ? const [TokenType.as, TokenType.$with] : [TokenType.$with]; if (enableDriftExtensions && (_match(types))) { final first = _previous; final useExisting = _previous.type == TokenType.$with; final name = _consumeIdentifier('Expected the name for the data class').identifier; return DriftTableName(name, useExisting)..setSpan(first, _previous); } return null; } /// Parses a "CREATE TRIGGER" statement, assuming that the create token has /// already been consumed. CreateTriggerStatement? _createTrigger() { final create = _previous; assert(create.type == TokenType.create); if (!_matchOne(TokenType.trigger)) return null; final ifNotExists = _ifNotExists(); final trigger = _consumeIdentifier('Expected a name for the identifier'); TriggerMode mode; if (_matchOne(TokenType.before)) { mode = TriggerMode.before; } else if (_matchOne(TokenType.after)) { mode = TriggerMode.after; } else { const msg = 'Expected BEFORE, AFTER or INSTEAD OF'; _consume(TokenType.instead, msg); _consume(TokenType.of, msg); mode = TriggerMode.insteadOf; } TriggerTarget target; if (_matchOne(TokenType.delete)) { target = DeleteTarget() ..deleteToken = _previous ..setSpan(_previous, _previous); } else if (_matchOne(TokenType.insert)) { target = InsertTarget() ..insertToken = _previous ..setSpan(_previous, _previous); } else { final updateToken = _consume( TokenType.update, 'Expected DELETE, INSERT or UPDATE as a trigger'); final names = []; if (_matchOne(TokenType.of)) { do { final name = _consumeIdentifier('Expected column name in ON clause'); final reference = Reference(columnName: name.identifier) ..setSpan(name, name); names.add(reference); } while (_matchOne(TokenType.comma)); } target = UpdateTarget(names) ..updateToken = updateToken ..setSpan(updateToken, _previous); } _consume(TokenType.on, 'Expected ON'); _suggestHint(const TableNameDescription()); final nameToken = _consumeIdentifier('Expected a table name'); final tableRef = TableReference(nameToken.identifier) ..setSpan(nameToken, nameToken); if (_matchOne(TokenType.$for)) { const msg = 'Expected FOR EACH ROW'; _consume(TokenType.each, msg); _consume(TokenType.row, msg); } Expression? when; if (_matchOne(TokenType.when)) { when = expression(); } final block = _consumeBlock(); return CreateTriggerStatement( ifNotExists: ifNotExists, triggerName: trigger.identifier, mode: mode, target: target, onTable: tableRef, when: when, action: block, ) ..setSpan(create, _previous) ..triggerNameToken = trigger; } /// Parses a [CreateViewStatement]. The `CREATE` token must have already been /// accepted. CreateViewStatement? _createView() { final create = _previous; assert(create.type == TokenType.create); if (!_matchOne(TokenType.view)) return null; final ifNotExists = _ifNotExists(); final name = _consumeIdentifier('Expected a name for this view'); // Don't allow the "AS ClassName" syntax for views since it causes an // ambiguity with the regular view syntax. final driftTableName = _driftTableName(supportAs: false); List? columnNames; if (_matchOne(TokenType.leftParen)) { columnNames = _columnNames(); _consume(TokenType.rightParen, 'Expected closing bracket'); } _consume(TokenType.as, 'Expected AS SELECT'); final query = _fullSelect(); if (query == null) { _error('Expected a SELECT statement here'); } return CreateViewStatement( ifNotExists: ifNotExists, viewName: name.identifier, columns: columnNames, query: query, driftTableName: driftTableName, ) ..viewNameToken = name ..setSpan(create, _previous); } /// Parses a [CreateIndexStatement]. The `CREATE` token must have already been /// accepted. CreateIndexStatement? _createIndex() { final create = _previous; assert(create.type == TokenType.create); final unique = _matchOne(TokenType.unique); if (!_matchOne(TokenType.$index)) return null; final ifNotExists = _ifNotExists(); final name = _consumeIdentifier('Expected a name for this index'); _consume(TokenType.on, 'Expected ON table'); _suggestHint(const TableNameDescription()); final nameToken = _consumeIdentifier('Expected a table name'); final tableRef = TableReference(nameToken.identifier) ..setSpan(nameToken, nameToken); _consume(TokenType.leftParen, 'Expected indexed columns in parentheses'); final indexes = _indexedColumns(); _consume(TokenType.rightParen, 'Expected closing bracket'); Expression? where; if (_matchOne(TokenType.where)) { where = expression(); } return CreateIndexStatement( indexName: name.identifier, unique: unique, ifNotExists: ifNotExists, on: tableRef, columns: indexes, where: where, ) ..nameToken = name ..setSpan(create, _previous); } List _columnNames() { final columns = []; do { final colName = _consumeIdentifier('Expected a name for this column'); columns.add(colName.identifier); } while (_matchOne(TokenType.comma)); return columns; } List _indexedColumns() { final indexes = []; do { final expr = expression(); final mode = _orderingModeOrNull(); indexes.add(IndexedColumn(expr, mode)..setSpan(expr.first!, _previous)); } while (_matchOne(TokenType.comma)); return indexes; } /// Parses `IF NOT EXISTS` | epsilon bool _ifNotExists() { if (_matchOne(TokenType.$if)) { _consume(TokenType.not, 'Expected IF to be followed by NOT EXISTS'); _consume(TokenType.exists, 'Expected IF NOT to be followed by EXISTS'); return true; } return false; } ColumnDefinition _columnDefinition() { final name = _consume(TokenType.identifier, 'Expected a column name') as IdentifierToken; final typeTokens = _typeName(); String? typeName; if (typeTokens != null) { typeName = typeTokens.lexeme; } final constraints = []; ColumnConstraint? constraint; while ((constraint = _columnConstraint(orNull: true)) != null) { constraints.add(constraint!); } return ColumnDefinition( columnName: name.identifier, typeName: typeName, constraints: constraints, ) ..setSpan(name, _previous) ..typeNames = typeTokens ..nameToken = name; } List? _typeName() { // sqlite doesn't really define what a type name is and has very loose rules // at turning them into a type affinity. We support this pattern: // typename = identifier [ "(" { identifier | comma | number_literal } ")" ] if (!_matchOne(TokenType.identifier)) return null; final typeNames = [_previous]; if (_matchOne(TokenType.leftParen)) { typeNames.add(_previous); const inBrackets = [ TokenType.identifier, TokenType.comma, TokenType.numberLiteral ]; while (_match(inBrackets)) { typeNames.add(_previous); } _consume(TokenType.rightParen, 'Expected closing parenthesis to finish type name'); typeNames.add(_previous); } return typeNames; } ColumnConstraint? _columnConstraint({bool orNull = false}) { final first = _peek; final resolvedName = _constraintNameOrNull()?.identifier; if (_matchOne(TokenType.primary)) { _suggestHint(HintDescription.token(TokenType.key)); _consume(TokenType.key, 'Expected KEY to complete PRIMARY KEY clause'); final mode = _orderingModeOrNull(); final conflict = _conflictClauseOrNull(); _suggestHint(HintDescription.token(TokenType.autoincrement)); final hasAutoInc = _matchOne(TokenType.autoincrement); return PrimaryKeyColumn(resolvedName, autoIncrement: hasAutoInc, mode: mode, onConflict: conflict) ..setSpan(first, _previous); } if (_matchOne(TokenType.$null)) { final nullToken = _previous; return NullColumnConstraint(resolvedName, $null: nullToken) ..setSpan(nullToken, nullToken); } if (_matchOne(TokenType.not)) { _suggestHint(HintDescription.token(TokenType.$null)); final notToken = _previous; final nullToken = _consume(TokenType.$null, 'Expected NULL to complete NOT NULL'); return NotNull(resolvedName, onConflict: _conflictClauseOrNull()) ..setSpan(first, _previous) ..not = notToken ..$null = nullToken; } if (_matchOne(TokenType.unique)) { return UniqueColumn(resolvedName, _conflictClauseOrNull()) ..setSpan(first, _previous); } if (_matchOne(TokenType.check)) { final expr = _expressionInParentheses(); return CheckColumn(resolvedName, expr)..setSpan(first, _previous); } if (_matchOne(TokenType.$default)) { Expression expr; if (_match(const [TokenType.plus, TokenType.minus])) { // Signed number final operator = _previous; expr = UnaryExpression(operator, _numericLiteral()) ..setSpan(operator, _previous); } else { // Literal or an expression in parentheses expr = _literalOrNull() ?? _expressionInParentheses(); } return Default(resolvedName, expr)..setSpan(first, _previous); } if (_matchOne(TokenType.collate)) { final collation = _consumeIdentifier('Expected the collation name'); return CollateConstraint(resolvedName, collation.identifier) ..setSpan(first, _previous); } if (_matchOne(TokenType.generated)) { _consume(TokenType.always); _consume(TokenType.as); _consume(TokenType.leftParen); final expr = expression(); _consume(TokenType.rightParen); bool isStored; if (_matchOne(TokenType.stored)) { isStored = true; } else if (_matchOne(TokenType.virtual)) { isStored = false; } else { isStored = false; } return GeneratedAs(expr, name: resolvedName, stored: isStored) ..setSpan(first, _previous); } if (_peek.type == TokenType.references) { final clause = _foreignKeyClause(); return ForeignKeyColumnConstraint(resolvedName, clause) ..setSpan(first, _previous); } if (enableDriftExtensions && _matchOne(TokenType.mapped)) { _consume(TokenType.by, 'Expected a MAPPED BY constraint'); final dartExpr = _consume( TokenType.inlineDart, 'Expected Dart expression in backticks'); return MappedBy(resolvedName, dartExpr as InlineDartToken) ..setSpan(first, _previous); } if (enableDriftExtensions && _matchOne(TokenType.json)) { final jsonToken = _previous; final keyToken = _consume(TokenType.key, 'Expected a JSON KEY constraint'); final name = _consumeIdentifier('Expected a name for for the json key'); return JsonKey(resolvedName, name) ..setSpan(first, _previous) ..json = jsonToken ..key = keyToken; } if (enableDriftExtensions && _matchOne(TokenType.as)) { final asToken = _previous; final nameToken = _consumeIdentifier('Expected Dart getter name'); return DriftDartName(resolvedName, nameToken) ..setSpan(first, _previous) ..as = asToken; } // no known column constraint matched. If orNull is set and we're not // guaranteed to be in a constraint clause (started with CONSTRAINT), we // can return null if (orNull && resolvedName == null) { return null; } _error('Expected a constraint (primary key, nullability, etc.)'); } TableConstraint? _tableConstraintOrNull() { final first = _peek; final nameToken = _constraintNameOrNull(); final name = nameToken?.identifier; TableConstraint? result; if (_match([TokenType.unique, TokenType.primary])) { final isPrimaryKey = _previous.type == TokenType.primary; if (isPrimaryKey) { _consume(TokenType.key, 'Expected KEY to start PRIMARY KEY clause'); } _consume(TokenType.leftParen, 'Expected a left parenthesis to start key columns'); final columns = _indexedColumns(); _consume( TokenType.rightParen, 'Expected a closing parenthesis after columns'); final conflictClause = _conflictClauseOrNull(); result = KeyClause(name, isPrimaryKey: isPrimaryKey, columns: columns, onConflict: conflictClause); } else if (_matchOne(TokenType.check)) { final expr = _expressionInParentheses(); result = CheckTable(name, expr); } else if (_matchOne(TokenType.foreign)) { _consume(TokenType.key, 'Expected KEY to start FOREIGN KEY clause'); final columns = _listColumnsInParentheses(allowEmpty: false); final clause = _foreignKeyClause(); result = ForeignKeyTableConstraint(name, columns: columns, clause: clause); } if (result != null) { result ..setSpan(first, _previous) ..nameToken = nameToken; return result; } if (name != null) { // if a constraint was started with CONSTRAINT but then we didn't // find a constraint, that's an syntax error _error('Expected a table constraint (e.g. a primary key)'); } return null; } IdentifierToken? _constraintNameOrNull() { if (_matchOne(TokenType.constraint)) { final name = _consumeIdentifier('Expect a name for the constraint here'); return name; } return null; } Expression _expressionInParentheses() { _consume(TokenType.leftParen, 'Expected opening parenthesis'); final expr = expression(); _consume(TokenType.rightParen, 'Expected closing parenthesis'); return expr; } ConflictClause? _conflictClauseOrNull() { _suggestHint(HintDescription.token(TokenType.on)); if (_matchOne(TokenType.on)) { _consume(TokenType.conflict, 'Expected CONFLICT to complete ON CONFLICT clause'); const modes = { TokenType.rollback: ConflictClause.rollback, TokenType.abort: ConflictClause.abort, TokenType.fail: ConflictClause.fail, TokenType.ignore: ConflictClause.ignore, TokenType.replace: ConflictClause.replace, }; _suggestHint(HintDescription.tokens(modes.keys.toList())); if (_match(modes.keys)) { return modes[_previous.type]; } else { _error('Expected a conflict handler (rollback, abort, etc.) here'); } } return null; } TableReference _tableReference({bool allowAlias = true}) { _suggestHint(const TableNameDescription()); final first = _consumeIdentifier('Expected table or schema name here'); IdentifierToken? second; IdentifierToken? as; if (_matchOne(TokenType.dot)) { second = _consumeIdentifier('Expected a table name here'); } if (allowAlias) { as = _as(); } final tableNameToken = second ?? first; return TableReference( tableNameToken.identifier, as: as?.identifier, schemaName: second == null ? null : first.identifier, ) ..setSpan(first, _previous) ..tableNameToken = tableNameToken; } ForeignKeyClause _foreignKeyClause() { // https://www.sqlite.org/syntax/foreign-key-clause.html _consume(TokenType.references, 'Expected REFERENCES'); final firstToken = _previous; final foreignTable = _tableReference(allowAlias: false); final columnNames = _listColumnsInParentheses(allowEmpty: true); ReferenceAction? onDelete, onUpdate; _suggestHint(HintDescription.token(TokenType.on)); while (_matchOne(TokenType.on)) { _suggestHint( const HintDescription.tokens([TokenType.delete, TokenType.update])); if (_matchOne(TokenType.delete)) { onDelete = _referenceAction(); } else if (_matchOne(TokenType.update)) { onUpdate = _referenceAction(); } else { _error('Expected either DELETE or UPDATE'); } } DeferrableClause? deferrable; if (_checkWithNot(TokenType.deferrable)) { final first = _peekNext; final not = _matchOne(TokenType.not); _consume(TokenType.deferrable); InitialDeferrableMode? mode; if (_matchOne(TokenType.initially)) { if (_matchOne(TokenType.deferred)) { mode = InitialDeferrableMode.deferred; } else if (_matchOne(TokenType.immediate)) { mode = InitialDeferrableMode.immediate; } else { _error('Expected DEFERRED or IMMEDIATE here'); } } deferrable = DeferrableClause(not, mode)..setSpan(first, _previous); } return ForeignKeyClause( foreignTable: foreignTable, columnNames: columnNames, onUpdate: onUpdate, onDelete: onDelete, deferrable: deferrable, )..setSpan(firstToken, _previous); } ReferenceAction _referenceAction() { if (_matchOne(TokenType.cascade)) { return ReferenceAction.cascade; } else if (_matchOne(TokenType.restrict)) { return ReferenceAction.restrict; } else if (_matchOne(TokenType.no)) { _consume(TokenType.action, 'Expect ACTION to complete NO ACTION clause'); return ReferenceAction.noAction; } else if (_matchOne(TokenType.set)) { if (_matchOne(TokenType.$null)) { return ReferenceAction.setNull; } else if (_matchOne(TokenType.$default)) { return ReferenceAction.setDefault; } else { _error('Expected either NULL or DEFAULT as set action here'); } } else { _error('Not a valid action, expected CASCADE, SET NULL, etc..'); } } List _listColumnsInParentheses({bool allowEmpty = false}) { final columnNames = []; if (_matchOne(TokenType.leftParen)) { do { final referenceId = _consumeIdentifier('Expected a column name'); final reference = Reference(columnName: referenceId.identifier) ..setSpan(referenceId, referenceId); columnNames.add(reference); } while (_matchOne(TokenType.comma)); _consume(TokenType.rightParen, 'Expected closing paranthesis after column names'); } else { if (!allowEmpty) { _error('Expected a list of columns in parantheses'); } } return columnNames; } } extension on List { String get lexeme => first.span.expand(last.span).text; } lib/src/reader/tokenizer/utils.dart 644 0 0 1035 13764474313 15522 0ustar0 pubpubimport 'package:charcode/ascii.dart'; bool isDigit(int charCode) { return $0 <= charCode && charCode <= $9; } bool isHexDigit(int charCode) { return ($a <= charCode && charCode <= $f) || ($A <= charCode && charCode <= $F) || ($0 <= charCode && charCode <= $9); } bool canStartIdentifier(int charCode) { return charCode == $_ || ($a <= charCode && charCode <= $z) || ($A <= charCode && charCode <= $Z); } bool continuesIdentifier(int charCode) { return canStartIdentifier(charCode) || isDigit(charCode); } lib/src/reader/tokenizer/token.dart 644 0 0 37443 14206504757 15534 0ustar0 pubpubimport 'dart:math'; import 'package:meta/meta.dart'; import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; enum TokenType { $case, $default, $do, $else, $false, $for, $if, $in, $index, $is, $null, $true, $values, $with, abort, action, add, after, all, alter, always, ampersand, analyze, and, any, array, as, asc, asymmetric, atSignVariable, attach, autoincrement, before, begin, between, binary, both, by, cascade, cast, check, collate, colon, column, colonVariable, comma, comment, commit, conflict, constraint, create, cross, current, currentDate, currentTime, currentTimestamp, currentUser, database, /// `->`, extract subcomponent of JSON dashRangle, /// `->>`, extract subcomponent of JSON as SQL value. dashRangleRangle, deferrable, deferred, delete, desc, detach, distinct, dollarSignVariable, dot, doubleEqual, doublePipe, drop, each, end, eof, equal, escape, except, exclamationEqual, exclude, exclusive, exists, explain, fail, filter, first, following, foreign, from, full, generated, glob, grant, group, groups, having, identifier, ignore, ilike, immediate, indexed, initially, inner, insert, instead, intersect, into, isNull, join, key, last, leading, left, leftParen, less, lessEqual, lessMore, like, limit, localTime, localTimestamp, match, materialized, minus, more, moreEqual, natural, no, not, notNull, nothing, nulls, numberLiteral, of, offset, on, only, or, order, others, outer, over, overlaps, partition, placing, percent, pipe, plan, plus, pragma, preceding, primary, query, questionMarkVariable, range, raise, recursive, references, regexp, reindex, release, rename, replace, returning, restrict, right, rightParen, rollback, row, rowid, rows, savepoint, select, semicolon, set, sessionUser, shiftLeft, shiftRight, similar, slash, some, stored, star, strict, symmetric, stringLiteral, table, temp, temporary, then, ties, tilde, to, trailing, transaction, trigger, unbounded, union, unique, update, user, using, vacuum, view, virtual, when, where, window, without, /// Drift specific token, used to declare type converter mapped, inlineDart, import, json, required, list, /// A `**` token. This is only scanned when scanning for drift tokens. doubleStar, } const Map keywords = { 'ADD': TokenType.add, 'ABORT': TokenType.abort, 'ACTION': TokenType.action, 'AFTER': TokenType.after, 'ALL': TokenType.all, 'ALTER': TokenType.alter, 'ALWAYS': TokenType.always, 'ANALYZE': TokenType.analyze, 'AND': TokenType.and, 'AS': TokenType.as, 'ASC': TokenType.asc, 'ATTACH': TokenType.attach, 'AUTOINCREMENT': TokenType.autoincrement, 'BEFORE': TokenType.before, 'BEGIN': TokenType.begin, 'BETWEEN': TokenType.between, 'BY': TokenType.by, 'CASCADE': TokenType.cascade, 'CASE': TokenType.$case, 'CAST': TokenType.cast, 'CHECK': TokenType.check, 'COLLATE': TokenType.collate, 'COLUMN': TokenType.column, 'COMMIT': TokenType.commit, 'CONFLICT': TokenType.conflict, 'CONSTRAINT': TokenType.constraint, 'CREATE': TokenType.create, 'CROSS': TokenType.cross, 'CURRENT': TokenType.current, 'CURRENT_DATE': TokenType.currentDate, 'CURRENT_TIME': TokenType.currentTime, 'CURRENT_TIMESTAMP': TokenType.currentTimestamp, 'DATABASE': TokenType.database, 'DEFAULT': TokenType.$default, 'DEFERRABLE': TokenType.deferrable, 'DEFERRED': TokenType.deferred, 'DELETE': TokenType.delete, 'DESC': TokenType.desc, 'DETACH': TokenType.detach, 'DISTINCT': TokenType.distinct, 'DO': TokenType.$do, 'DROP': TokenType.drop, 'EACH': TokenType.each, 'ELSE': TokenType.$else, 'END': TokenType.end, 'ESCAPE': TokenType.escape, 'EXCEPT': TokenType.except, 'EXCLUDE': TokenType.exclude, 'EXCLUSIVE': TokenType.exclusive, 'EXISTS': TokenType.exists, 'EXPLAIN': TokenType.explain, 'FAIL': TokenType.fail, 'FALSE': TokenType.$false, 'FILTER': TokenType.filter, 'FIRST': TokenType.first, 'FOLLOWING': TokenType.following, 'FOR': TokenType.$for, 'FOREIGN': TokenType.foreign, 'FROM': TokenType.from, 'FULL': TokenType.full, 'GENERATED': TokenType.generated, 'GLOB': TokenType.glob, 'GROUP': TokenType.group, 'GROUPS': TokenType.groups, 'HAVING': TokenType.having, 'IF': TokenType.$if, 'IGNORE': TokenType.ignore, 'IMMEDIATE': TokenType.immediate, 'IN': TokenType.$in, 'INDEX': TokenType.$index, 'INDEXED': TokenType.indexed, 'INITIALLY': TokenType.initially, 'INNER': TokenType.inner, 'INSERT': TokenType.insert, 'INSTEAD': TokenType.instead, 'INTERSECT': TokenType.intersect, 'INTO': TokenType.into, 'IS': TokenType.$is, 'ISNULL': TokenType.isNull, 'JOIN': TokenType.join, 'KEY': TokenType.key, 'LAST': TokenType.last, 'LEADING': TokenType.leading, 'LEFT': TokenType.left, 'LIKE': TokenType.like, 'LIMIT': TokenType.limit, 'MATCH': TokenType.match, 'MATERIALIZED': TokenType.materialized, 'NATURAL': TokenType.natural, 'NO': TokenType.no, 'NOT': TokenType.not, 'NOTHING': TokenType.nothing, 'NOTNULL': TokenType.notNull, 'NULL': TokenType.$null, 'NULLS': TokenType.nulls, 'OF': TokenType.of, 'OFFSET': TokenType.offset, 'ON': TokenType.on, 'OR': TokenType.or, 'ORDER': TokenType.order, 'OTHERS': TokenType.others, 'OUTER': TokenType.outer, 'OVER': TokenType.over, 'PARTITION': TokenType.partition, 'PLAN': TokenType.plan, 'PRAGMA': TokenType.pragma, 'PRECEDING': TokenType.preceding, 'PRIMARY': TokenType.primary, 'QUERY': TokenType.query, 'RAISE': TokenType.raise, 'RANGE': TokenType.range, 'RECURSIVE': TokenType.recursive, 'REFERENCES': TokenType.references, 'REGEXP': TokenType.regexp, 'REINDEX': TokenType.reindex, 'RELEASE': TokenType.release, 'RENAME': TokenType.rename, 'REPLACE': TokenType.replace, 'RIGHT': TokenType.right, 'RETURNING': TokenType.returning, 'RESTRICT': TokenType.restrict, 'ROLLBACK': TokenType.rollback, 'ROW': TokenType.row, 'ROWID': TokenType.rowid, 'ROWS': TokenType.rows, 'SAVEPOINT': TokenType.savepoint, 'SELECT': TokenType.select, 'SET': TokenType.set, 'STORED': TokenType.stored, 'STRICT': TokenType.strict, 'TABLE': TokenType.table, 'TEMP': TokenType.temp, 'TEMPORARY': TokenType.temporary, 'THEN': TokenType.then, 'TIES': TokenType.ties, 'TO': TokenType.to, 'TRANSACTION': TokenType.transaction, 'TRIGGER': TokenType.trigger, 'TRUE': TokenType.$true, 'UNBOUNDED': TokenType.unbounded, 'UNION': TokenType.union, 'UNIQUE': TokenType.unique, 'UPDATE': TokenType.update, 'USING': TokenType.using, 'VACUUM': TokenType.vacuum, 'VALUES': TokenType.$values, 'VIEW': TokenType.view, 'VIRTUAL': TokenType.virtual, 'WHEN': TokenType.when, 'WHERE': TokenType.where, 'WINDOW': TokenType.window, 'WITH': TokenType.$with, 'WITHOUT': TokenType.without, }; const Map postgresKeywords = { 'ANY': TokenType.any, 'ARRAY': TokenType.array, 'ASYMMETRIC': TokenType.asymmetric, 'BINARY': TokenType.binary, 'BOTH': TokenType.both, 'CURRENT_USER': TokenType.currentUser, 'ILIKE': TokenType.ilike, 'LEADING': TokenType.leading, 'LOCALTIME': TokenType.localTime, 'LOCALTIMESTAMP': TokenType.localTimestamp, 'GRANT': TokenType.grant, 'ONLY': TokenType.only, 'OVERLAPS': TokenType.overlaps, 'PLACING': TokenType.placing, 'SESSION_USER': TokenType.sessionUser, 'SIMILAR': TokenType.similar, 'SOME': TokenType.some, 'SYMMETRIC': TokenType.symmetric, 'TRAILING': TokenType.trailing, 'USER': TokenType.user, }; /// Maps [TokenType]s which are keywords to their lexeme. final Map reverseKeywords = { for (var entry in keywords.entries) entry.value: entry.key, for (var entry in driftKeywords.entries) entry.value: entry.key, }; const Map driftKeywords = { 'IMPORT': TokenType.import, 'JSON': TokenType.json, 'MAPPED': TokenType.mapped, 'REQUIRED': TokenType.required, 'LIST': TokenType.list, }; /// A set of [TokenType]s that can be parsed as an identifier. const Set _identifierKeywords = { TokenType.join, TokenType.rowid, }; /// Returns true if the [type] belongs to a keyword bool isKeyword(TokenType type) => reverseKeywords.containsKey(type); /// Returns true if [name] is a reserved keyword in sqlite. bool isKeywordLexeme(String name) => keywords.containsKey(name.toUpperCase()); /// Returns true if [name] is a reserved keyword in postgres. bool isPostgresKeywordLexeme(String name) => postgresKeywords.containsKey(name.toUpperCase()); class Token implements SyntacticEntity { final TokenType type; /// Whether this token should be invisible to the parser. We use this for /// comment tokens. bool get invisibleToParser => false; @override final FileSpan span; String get lexeme => span.text; /// The index of this [Token] in the list of tokens scanned. late int index; Token(this.type, this.span); @override bool get hasSpan => true; @override String toString() { return '$type: $lexeme'; } @override int get firstPosition => span.start.offset; @override int get lastPosition => span.end.offset; @override bool get synthetic => false; } class StringLiteralToken extends Token { final String value; /// sqlite allows binary strings (x'literal') which are interpreted as blobs. final bool binary; StringLiteralToken(this.value, FileSpan span, {this.binary = false}) : super(TokenType.stringLiteral, span); } class IdentifierToken extends Token { /// Whether this identifier was escaped by putting it in "double ticks". final bool escaped; /// Whether this identifier token is synthetic. We sometimes convert /// [KeywordToken]s to identifiers if they're unambiguous, in which case /// [synthetic] will be true on this token because it was not scanned as such. @override final bool synthetic; String get identifier { if (escaped) { return lexeme.substring(1, lexeme.length - 1); } else { return lexeme; } } IdentifierToken(this.escaped, FileSpan span, {this.synthetic = false}) : super(TokenType.identifier, span); } abstract class VariableToken extends Token { VariableToken(TokenType type, FileSpan span) : super(type, span); } class QuestionMarkVariableToken extends Token { /// The explicit index, if this variable was of the form `?123`. Otherwise /// null. final int? explicitIndex; QuestionMarkVariableToken(FileSpan span, this.explicitIndex) : super(TokenType.questionMarkVariable, span); } class ColonVariableToken extends Token { final String name; ColonVariableToken(FileSpan span, this.name) : super(TokenType.colonVariable, span); } class DollarSignVariableToken extends Token { final String name; DollarSignVariableToken(FileSpan span, this.name) : super(TokenType.dollarSignVariable, span); } class AtSignVariableToken extends Token { final String name; AtSignVariableToken(FileSpan span, this.name) : super(TokenType.atSignVariable, span); } /// Inline Dart appearing in a create table statement. Only parsed when the /// drift extensions are enabled. Dart code is wrapped in backticks. class InlineDartToken extends Token { InlineDartToken(FileSpan span) : super(TokenType.inlineDart, span); String get dartCode { // strip the backticks return lexeme.substring(1, lexeme.length - 1); } } /// Used for tokens that are keywords. We use this special class without any /// additional properties to ease syntax highlighting, as it allows us to find /// the keywords easily. class KeywordToken extends Token { /// Whether this token has been used as an identifier while parsing. bool isIdentifier = false; KeywordToken(TokenType type, FileSpan span) : super(type, span); bool canConvertToIdentifier() { // https://stackoverflow.com/a/45775719, but we don't parse indexed yet. return _identifierKeywords.contains(type) || driftKeywords.values.contains(type); } IdentifierToken convertToIdentifier() { isIdentifier = true; return IdentifierToken(false, span, synthetic: true); } } /// Used to represent additional information of [TokenType.numberLiteral]. /// /// For more details, see the docs on https://www.sqlite.org/syntax/numeric-literal.html class NumericToken extends Token { /// The digits before the decimal point, or null if this numeric token was /// written in hexadecimal notation or started with a decimal point. String? digitsBeforeDecimal; /// Whether this token has a decimal point in it. bool hasDecimalPoint; /// The digits after the decimal point, or null if this numeric token doesn't /// have anything after its decimal point. String? digitsAfterDecimal; /// The hexadecimal digits of this token, or null if this token was not in /// hex notation. String? hexDigits; /// An exponent to the base of ten. /// /// For instance, `2E-2` has an [exponent] of `-2`. final int? exponent; NumericToken( FileSpan span, { this.digitsBeforeDecimal, this.hasDecimalPoint = false, this.digitsAfterDecimal, this.hexDigits, this.exponent, }) : super(TokenType.numberLiteral, span); /// The numeric literal represented by this token. num get parsedNumber { if (hexDigits != null) { return int.parse(hexDigits!, radix: 16); } final beforeDecimal = digitsBeforeDecimal != null ? int.parse(digitsBeforeDecimal!) : 0; num number; if (!hasDecimalPoint) { number = beforeDecimal; } else if (digitsAfterDecimal != null) { number = beforeDecimal + double.parse('.$digitsAfterDecimal'); } else { // Is of the form 3., so just infer as double number = beforeDecimal.toDouble(); } if (exponent != null) { number *= pow(10, exponent!); } return number; } @visibleForTesting bool hasSameStructureAs(NumericToken other) { return other.digitsBeforeDecimal == digitsBeforeDecimal && other.hasDecimalPoint == hasDecimalPoint && other.digitsAfterDecimal == digitsAfterDecimal && other.hexDigits == hexDigits && other.exponent == exponent; } @override String toString() { final buffer = StringBuffer(); if (hexDigits != null) { buffer ..write('0x') ..write(hexDigits); } else { if (digitsBeforeDecimal != null) { buffer.write(digitsBeforeDecimal); } if (hasDecimalPoint) { buffer.write('.'); } if (digitsAfterDecimal != null) { buffer.write(digitsAfterDecimal); } if (exponent != null) { buffer ..write('E') ..write(exponent); } } return buffer.toString(); } } enum CommentMode { line, cStyle } /// A comment, either started with -- or with /*. class CommentToken extends Token { final CommentMode mode; /// The content of this comment, excluding the "--", "/*", "*/". final String content; @override final bool invisibleToParser = true; CommentToken(this.mode, this.content, FileSpan span) : super(TokenType.comment, span); } class TokenizerError { final String message; final SourceLocation location; TokenizerError(this.message, this.location); @override String toString() { return '$message at $location'; } } /// Thrown by the sql engine when a sql statement can't be tokenized. class CumulatedTokenizerException implements Exception { final List errors; CumulatedTokenizerException(this.errors); @override String toString() { final explanation = errors.map((e) => '${e.message} at ${e.location}').join(', '); return 'Malformed sql: $explanation'; } } lib/src/reader/tokenizer/scanner.dart 644 0 0 32124 14206506234 16024 0ustar0 pubpubimport 'dart:typed_data'; import 'package:charcode/charcode.dart'; import 'package:source_span/source_span.dart'; import 'token.dart'; import 'utils.dart'; class Scanner { final String source; final Uint16List _charCodes; /// Whether to scan tokens that are only relevant for drift files. final bool scanDriftTokens; final SourceFile _file; final List tokens = []; final List errors = []; int _startOffset = 0; int _currentOffset = 0; bool get _isAtEnd => _currentOffset >= source.length; FileSpan get _currentSpan { return _file.span(_startOffset, _currentOffset); } SourceLocation get _currentLocation { return _file.location(_currentOffset); } Scanner(this.source, {this.scanDriftTokens = false}) : _file = SourceFile.fromString(source), _charCodes = Uint16List.fromList(source.codeUnits); List scanTokens() { while (!_isAtEnd) { _startOffset = _currentOffset; _scanToken(); } final endSpan = _file.span(source.length); tokens.add(Token(TokenType.eof, endSpan)); for (var i = 0; i < tokens.length; i++) { tokens[i].index = i; } if (errors.isNotEmpty) { throw CumulatedTokenizerException(errors); } return tokens; } void _scanToken() { final char = _nextChar(); switch (char) { case $lparen: _addToken(TokenType.leftParen); break; case $rparen: _addToken(TokenType.rightParen); break; case $comma: _addToken(TokenType.comma); break; case $dot: if (!_isAtEnd && isDigit(_peek())) { _numeric(char); } else { _addToken(TokenType.dot); } break; case $plus: _addToken(TokenType.plus); break; case $minus: if (_match($minus)) { _lineComment(); } else if (_match($rangle)) { _addToken(_match($rangle) ? TokenType.dashRangleRangle : TokenType.dashRangle); } else { _addToken(TokenType.minus); } break; case $asterisk: if (scanDriftTokens && _match($asterisk)) { _addToken(TokenType.doubleStar); } else { _addToken(TokenType.star); } break; case $slash: if (_match($asterisk)) { _cStyleComment(); } else { _addToken(TokenType.slash); } break; case $percent: _addToken(TokenType.percent); break; case $ampersand: _addToken(TokenType.ampersand); break; case $pipe: _addToken(_match($pipe) ? TokenType.doublePipe : TokenType.pipe); break; case $less_than: if (_match($equal)) { _addToken(TokenType.lessEqual); } else if (_match($less_than)) { _addToken(TokenType.shiftLeft); } else if (_match($greater_than)) { _addToken(TokenType.lessMore); } else { _addToken(TokenType.less); } break; case $greater_than: if (_match($equal)) { _addToken(TokenType.moreEqual); } else if (_match($greater_than)) { _addToken(TokenType.shiftRight); } else { _addToken(TokenType.more); } break; case $exclamation: if (_match($equal)) { _addToken(TokenType.exclamationEqual); } else { _unexpectedToken(); } break; case $equal: _addToken(_match($equal) ? TokenType.doubleEqual : TokenType.equal); break; case $tilde: _addToken(TokenType.tilde); break; case $question: // if the next chars are numbers, this is an explicitly indexed variable final buffer = StringBuffer(); while (!_isAtEnd && isDigit(_peek())) { buffer.writeCharCode(_nextChar()); } int? explicitIndex; if (buffer.isNotEmpty) { explicitIndex = int.parse(buffer.toString()); } tokens.add(QuestionMarkVariableToken(_currentSpan, explicitIndex)); break; case $colon: final name = _matchColumnName(); if (name == null) { _addToken(TokenType.colon); } else { tokens.add(ColonVariableToken(_currentSpan, ':$name')); } break; case $dollar: final name = _matchColumnName()!; tokens.add(DollarSignVariableToken(_currentSpan, name)); break; case $at: final name = _matchColumnName()!; tokens.add(AtSignVariableToken(_currentSpan, name)); break; case $semicolon: _addToken(TokenType.semicolon); break; case $x: case $X: if (_match($apostrophe)) { _string(binary: true); } else { _identifier(); } break; case $apostrophe: _string(); break; case $double_quote: _identifier(escapeChar: $double_quote); break; case $backquote: if (scanDriftTokens) { _inlineDart(); } else { _identifier(escapeChar: $backquote); } break; case $lbracket: _identifier(escapeChar: $rbracket); break; case $space: case $cr: case $tab: case $lf: // ignore whitespace break; default: if (isDigit(char)) { _numeric(char); } else if (canStartIdentifier(char)) { _identifier(); } else { _unexpectedToken(); } break; } } void _unexpectedToken() { errors.add(TokenizerError('Unexpected character', _currentLocation)); } @pragma('vm:prefer-inline') int _nextChar() { _advance(); return _charCodes[_currentOffset - 1]; } @pragma('vm:prefer-inline') void _advance() => _currentOffset++; int _peek() { if (_isAtEnd) throw StateError('Reached end of source'); return _charCodes[_currentOffset]; } bool _match(int expected) { if (_isAtEnd) return false; if (_peek() != expected) { return false; } _currentOffset++; return true; } void _addToken(TokenType type) { tokens.add(Token(type, _currentSpan)); } void _string({bool binary = false}) { var properlyClosed = false; while (!_isAtEnd) { final char = _nextChar(); // single quote could be an escape (when there are two of them) or the // end of this string literal if (char == $apostrophe) { if (!_isAtEnd && _peek() == $apostrophe) { _advance(); continue; } properlyClosed = true; break; } } // Issue an error if the string is unterminated if (!properlyClosed) { errors.add(TokenizerError('Unterminated string', _currentLocation)); } final value = source .substring(_startOffset + 1, _currentOffset - 1) .replaceAll("''", "'"); tokens.add(StringLiteralToken(value, _currentSpan, binary: binary)); } void _numeric(int firstChar) { // https://www.sqlite.org/syntax/numeric-literal.html // We basically have three cases: hexadecimal numbers (starting with 0x), // numbers starting with a decimal dot and numbers starting with a digit. if (firstChar == $0) { if (!_isAtEnd && (_peek() == $x || _peek() == $X)) { _nextChar(); // consume the x final hexDigitsBuffer = StringBuffer(); // advance hexadecimal digits while (!_isAtEnd && isHexDigit(_peek())) { hexDigitsBuffer.writeCharCode(_nextChar()); } tokens.add( NumericToken(_currentSpan, hexDigits: hexDigitsBuffer.toString())); return; } } String consumeDigits() { final buffer = StringBuffer(); while (!_isAtEnd && isDigit(_peek())) { buffer.writeCharCode(_nextChar()); } return buffer.toString(); } /// Returns true without advancing if the next char is a digit. Returns /// false and logs an error with the message otherwise. bool _requireDigit(String message) { final noDigit = _isAtEnd || !isDigit(_peek()); if (noDigit) { errors.add(TokenizerError(message, _currentLocation)); } return !noDigit; } String? beforeDecimal; String? afterDecimal; var hasDecimal = false; // ok, we're not dealing with a hexadecimal number. if (firstChar == $dot) { // started with a decimal point. the next char has to be numeric hasDecimal = true; if (_requireDigit('Expected a digit after the decimal dot')) { afterDecimal = consumeDigits(); } } else { // ok, not starting with a decimal dot. In that case, the first char must // be a digit if (!isDigit(firstChar)) { errors.add(TokenizerError('Expected a digit', _currentLocation)); return; } beforeDecimal = String.fromCharCode(firstChar) + consumeDigits(); // optional decimal part if (!_isAtEnd && _peek() == $dot) { _nextChar(); hasDecimal = true; final digits = consumeDigits(); if (digits.isNotEmpty) { afterDecimal = digits; } } } int? parsedExponent; // ok, we've read the first part of the number. But there's more! If it's // not a hexadecimal number, it could be in scientific notation. if (!_isAtEnd && (_peek() == $e || _peek() == $E)) { _nextChar(); // consume e or E if (_isAtEnd) { errors.add(TokenizerError( 'Unexpected end of file. ' 'Expected digits for the scientific notation', _currentLocation)); return; } final char = _nextChar(); if (isDigit(char)) { final exponent = String.fromCharCode(char) + consumeDigits(); parsedExponent = int.parse(exponent); } else { if (char == $plus || char == $minus) { _requireDigit('Expected digits for the exponent'); final exponent = consumeDigits(); parsedExponent = char == $plus ? int.parse(exponent) : -int.parse(exponent); } else { errors .add(TokenizerError('Expected plus or minus', _currentLocation)); } } } tokens.add(NumericToken(_currentSpan, digitsBeforeDecimal: beforeDecimal, digitsAfterDecimal: afterDecimal, hasDecimalPoint: hasDecimal, exponent: parsedExponent)); } void _identifier({int? escapeChar}) { if (escapeChar != null) { // find the closing quote while (!_isAtEnd && _peek() != escapeChar) { _nextChar(); } // Issue an error if the column name is unterminated if (_isAtEnd) { errors .add(TokenizerError('Unterminated column name', _currentLocation)); } else { // consume the closing char _nextChar(); tokens.add(IdentifierToken(true, _currentSpan)); } } else { while (!_isAtEnd && continuesIdentifier(_peek())) { _nextChar(); } // not escaped, so it could be a keyword final text = _currentSpan.text.toUpperCase(); if (keywords.containsKey(text)) { tokens.add(KeywordToken(keywords[text]!, _currentSpan)); } else if (scanDriftTokens && driftKeywords.containsKey(text)) { tokens.add(KeywordToken(driftKeywords[text]!, _currentSpan)); } else { tokens.add(IdentifierToken(false, _currentSpan)); } } } String? _matchColumnName() { if (_isAtEnd || !canStartIdentifier(_peek())) return null; final buffer = StringBuffer()..writeCharCode(_nextChar()); while (!_isAtEnd && continuesIdentifier(_peek())) { buffer.writeCharCode(_nextChar()); } return buffer.toString(); } void _inlineDart() { // inline starts with a `, we just need to find the matching ` that // terminates this token. while (_peek() != $backquote && !_isAtEnd) { _nextChar(); } if (_isAtEnd) { errors.add( TokenizerError('Unterminated inline Dart code', _currentLocation)); } else { // consume the ` _nextChar(); tokens.add(InlineDartToken(_currentSpan)); } } /// Scans a line comment after the -- has already been read. void _lineComment() { final contentBuilder = StringBuffer(); while (!_isAtEnd && _peek() != $lf) { contentBuilder.writeCharCode(_nextChar()); } tokens.add(CommentToken( CommentMode.line, contentBuilder.toString(), _currentSpan)); } /// Scans a /* ... */ comment after the first /* has already been read. /// Note that in sqlite, these comments don't have to be terminated - they /// will be closed by the end of input without causing a parsing error. void _cStyleComment() { final contentBuilder = StringBuffer(); while (!_isAtEnd) { if (_match($asterisk)) { if (!_isAtEnd && _match($slash)) { break; } else { // write the * we otherwise forgot to write contentBuilder.writeCharCode($asterisk); } } else { contentBuilder.writeCharCode(_nextChar()); } } tokens.add(CommentToken( CommentMode.cStyle, contentBuilder.toString(), _currentSpan)); } } lib/src/reader/syntactic_entity.dart 644 0 0 4600 14131303604 15725 0ustar0 pubpubimport 'package:source_span/source_span.dart'; /// Interface for entities that appear in a piece of text. As far as the /// parser is concerned, this contains tokens and ast nodes. abstract class SyntacticEntity { /// Whether this entity has a source span associated with it. bool get hasSpan; /// The piece of text forming this syntactic entity. FileSpan? get span; /// The first position of this entity, as an zero-based offset in the file it /// was read from. /// /// Instead of returning null, this getter may throw for entities where /// [hasSpan] is false. int get firstPosition; /// The (exclusive) last index of this entity in the source. /// /// Instead of returning null, this getter may throw for entities where /// [hasSpan] is false. int get lastPosition; /// Whether this entity is synthetic, meaning that it doesn't appear in the /// actual source. bool get synthetic; } /// Extension to report the length of a [SyntacticEntity]. extension SyntacticLengthExtension on SyntacticEntity { /// The length of this entity, in characters. int get length => lastPosition - firstPosition; } /// Extension to obtain the span for a sequence of [SyntacticEntity]. extension UnionEntityExtension on Iterable { /// Creates the span covered by all of the entities in this iterable. FileSpan get span { if (isEmpty) { throw ArgumentError.value(this, 'this', 'Was empty'); } final firstSpan = first.span; return skip(1).fold( firstSpan!, (previousValue, entity) => previousValue.expand(entity.span!), ); } /// Returns the common [span] of these syntactic entities, or `null` if the /// iterable is empty. FileSpan? get spanOrNull { return isEmpty ? null : span; } /// Returns a single [SyntacticEntity] representing this range of entities. SyntacticEntity get toSingleEntity => _UnionSyntacticEntity(toList()); } class _UnionSyntacticEntity extends SyntacticEntity { final List _members; _UnionSyntacticEntity(this._members); @override int get firstPosition => _members.first.firstPosition; @override bool get hasSpan => _members.any((entity) => entity.hasSpan); @override int get lastPosition => _members.last.lastPosition; @override FileSpan? get span => _members.spanOrNull; @override bool get synthetic => _members.every((entity) => entity.synthetic); } lib/src/utils/ast_equality.dart 644 0 0 54417 14211621724 14772 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:sqlparser/src/ast/ast.dart'; /// Checks whether [a] and [b] are equal. If they aren't, throws an exception. void enforceEqual(AstNode a, AstNode b) { EqualityEnforcingVisitor(a).visit(b, null); } void enforceEqualIterable(Iterable a, Iterable b) { final childrenA = a.iterator; final childrenB = b.iterator; var movedA = false; var movedB = false; // always move both iterators // need to store the result so it can be compared afterwards // since it does not get reverted if only one moved while ((movedA = childrenA.moveNext()) & (movedB = childrenB.moveNext())) { enforceEqual(childrenA.current, childrenB.current); } if (movedA || movedB) { throw ArgumentError("$a and $b don't have an equal amount of children"); } } /// Visitor enforcing the equality of two ast nodes. class EqualityEnforcingVisitor implements AstVisitor { // The current ast node. Visitor methods will compare the node they receive to // this one. AstNode _current; // Whether to check for deep equality too. final bool _considerChildren; /// Creates a visitor enforcing equality to the given node. /// /// The [visit] methods of this visitor will throw an [NotEqualException] /// if they receive a node that is different to the node passed here. /// /// When [considerChildren] is true (the default), it also considers child /// nodes, thus enforcing deep equality. EqualityEnforcingVisitor(this._current, {bool considerChildren = true}) : _considerChildren = considerChildren; @override void visitAggregateFunctionInvocation( AggregateFunctionInvocation e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitBeginTransaction(BeginTransactionStatement e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitBetweenExpression(BetweenExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitBinaryExpression(BinaryExpression e, void arg) { final current = _currentAs(e); _assert(current.operator.type == e.operator.type, e); _checkChildren(e); } @override void visitBlock(Block block, void arg) { _currentAs(block); _checkChildren(block); } @override void visitBooleanLiteral(BooleanLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value, e); _checkChildren(e); } @override void visitCaseExpression(CaseExpression e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCastExpression(CastExpression e, void arg) { final current = _currentAs(e); _assert(current.typeName == e.typeName, e); _checkChildren(e); } @override void visitCollateExpression(CollateExpression e, void arg) { final current = _currentAs(e); _assert(current.collateFunction.type == e.collateFunction.type, e); _checkChildren(e); } @override void visitColumnConstraint(ColumnConstraint e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); if (e is NotNull) { _assert(current is NotNull && current.onConflict == e.onConflict, e); } else if (e is PrimaryKeyColumn) { _assert( current is PrimaryKeyColumn && current.autoIncrement == e.autoIncrement && current.mode == e.mode && current.onConflict == e.onConflict, e); } else if (e is UniqueColumn) { _assert(current is UniqueColumn && current.onConflict == e.onConflict, e); } else if (e is CheckColumn) { _assert(current is CheckColumn, e); } else if (e is MappedBy) { _assert( current is MappedBy && current.mapper.dartCode == e.mapper.dartCode, e); } else if (e is JsonKey) { _assert(current is JsonKey && current.jsonKey == e.jsonKey, e); } else if (e is GeneratedAs) { _assert(current is GeneratedAs && current.stored == e.stored, e); } else { _assert(current.runtimeType == e.runtimeType, e); } _checkChildren(e); } @override void visitColumnDefinition(ColumnDefinition e, void arg) { final current = _currentAs(e); _assert( current.columnName == e.columnName && current.typeName == e.typeName, e); _checkChildren(e); } @override void visitCommitStatement(CommitStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCommonTableExpression(CommonTableExpression e, void arg) { final current = _currentAs(e); _assert(current.cteTableName == e.cteTableName, e); _assert(current.materializationHint == e.materializationHint, e); _assert( const ListEquality().equals(current.columnNames, current.columnNames), e); _checkChildren(e); } @override void visitCompoundSelectPart(CompoundSelectPart e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitCompoundSelectStatement(CompoundSelectStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitCreateIndexStatement(CreateIndexStatement e, void arg) { final current = _currentAs(e); _assert( current.indexName == e.indexName && current.unique == e.unique && current.ifNotExists == e.ifNotExists, e); _checkChildren(e); } @override void visitCreateTableStatement(CreateTableStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.tableName == e.tableName && current.withoutRowId == e.withoutRowId && current.isStrict == e.isStrict, e); _checkChildren(e); } @override void visitCreateTriggerStatement(CreateTriggerStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.triggerName == e.triggerName && current.mode == e.mode, e); _checkChildren(e); } @override void visitCreateViewStatement(CreateViewStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.viewName == e.viewName && const ListEquality().equals(current.columns, e.columns), e); _checkChildren(e); } @override void visitCreateVirtualTableStatement( CreateVirtualTableStatement e, void arg) { final current = _currentAs(e); _assert( current.ifNotExists == e.ifNotExists && current.tableName == e.tableName && current.moduleName == e.moduleName && const ListEquality() .equals(current.argumentContent, e.argumentContent), e); _checkChildren(e); } void visitDartPlaceholder(DartPlaceholder e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && current.runtimeType == e.runtimeType, e); _checkChildren(e); } @override void visitDefaultValues(DefaultValues e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDeferrableClause(DeferrableClause e, void arg) { final current = _currentAs(e); _assert( current.not == e.not && current.declaredInitially == e.declaredInitially, e); _checkChildren(e); } @override void visitDeleteStatement(DeleteStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDeleteTriggerTarget(DeleteTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDoNothing(DoNothing e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitDoUpdate(DoUpdate e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitExists(ExistsExpression e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitExpressionFunctionParameters(ExprFunctionParameters e, void arg) { final current = _currentAs(e); _assert(current.distinct == e.distinct, e); _checkChildren(e); } @override void visitExpressionResultColumn(ExpressionResultColumn e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitForeignKeyClause(ForeignKeyClause e, void arg) { final current = _currentAs(e); _assert( current.onDelete == e.onDelete && current.onUpdate == e.onUpdate, e); _checkChildren(e); } @override void visitFrameSpec(FrameSpec e, void arg) { final current = _currentAs(e); _assert( current.type == e.type && current.excludeMode == e.excludeMode && current.start == e.start && e.end == e.end, e); _checkChildren(e); } @override void visitFunction(FunctionExpression e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitGroupBy(GroupBy e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitIndexedColumn(IndexedColumn e, void arg) { final current = _currentAs(e); _assert(current.ordering == e.ordering, e); _checkChildren(e); } @override void visitInExpression(InExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitInsertStatement(InsertStatement e, void arg) { final current = _currentAs(e); _assert(current.mode == e.mode, e); _checkChildren(e); } @override void visitInsertTriggerTarget(InsertTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitInvalidStatement(InvalidStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitIsExpression(IsExpression e, void arg) { final current = _currentAs(e); _assert(current.negated == e.negated, e); _checkChildren(e); } @override void visitIsNullExpression(IsNullExpression e, void arg) { final current = _currentAs(e); _assert(current.negated == e.negated, e); _checkChildren(e); } @override void visitJoin(Join e, void arg) { final current = _currentAs(e); if (current.natural != e.natural || current.operator != e.operator) { _notEqual(e); } final constraint = current.constraint; if (constraint is OnConstraint) { _assert(e.constraint is OnConstraint, e); } else if (constraint is UsingConstraint) { if (e.constraint is! UsingConstraint) { _notEqual(e); } final typedOther = e.constraint as UsingConstraint; _assert( const ListEquality() .equals(constraint.columnNames, typedOther.columnNames), e); } _checkChildren(e); } @override void visitJoinClause(JoinClause e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitLimit(Limit e, void arg) { _currentAs(e); _checkChildren(e); } void visitDriftDeclaredStatement(DeclaredStatement e, void arg) { final current = _currentAs(e); _assert(current.identifier == e.identifier && current.as == e.as, e); _checkChildren(e); } void visitDriftFile(DriftFile e, void arg) { _currentAs(e); _checkChildren(e); } void visitDriftImportStatement(ImportStatement e, void arg) { final current = _currentAs(e); _assert(current.importedFile == e.importedFile, e); _checkChildren(e); } void visitDriftNestedStarResultColumn(NestedStarResultColumn e, void arg) { final current = _currentAs(e); _assert(current.tableName == e.tableName, e); _assert(current.as == e.as, e); _checkChildren(e); } void visitDriftNestedQueryColumn(NestedQueryColumn e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitDriftSpecificNode(DriftSpecificNode e, void arg) { if (e is DartPlaceholder) { return visitDartPlaceholder(e, arg); } else if (e is DeclaredStatement) { return visitDriftDeclaredStatement(e, arg); } else if (e is DriftFile) { return visitDriftFile(e, arg); } else if (e is ImportStatement) { return visitDriftImportStatement(e, arg); } else if (e is NestedStarResultColumn) { return visitDriftNestedStarResultColumn(e, arg); } else if (e is StatementParameter) { return visitDriftStatementParameter(e, arg); } else if (e is DriftTableName) { return visitDriftTableName(e, arg); } else if (e is NestedQueryColumn) { return visitDriftNestedQueryColumn(e, arg); } } void visitDriftStatementParameter(StatementParameter e, void arg) { if (e is VariableTypeHint) { final current = _currentAs(e); _assert( current.typeName == e.typeName && current.orNull == e.orNull && current.isRequired == e.isRequired, e); } else if (e is DartPlaceholderDefaultValue) { final current = _currentAs(e); _assert(current.variableName == e.variableName, e); } _checkChildren(e); } void visitDriftTableName(DriftTableName e, void arg) { final current = _currentAs(e); _assert( current.overriddenDataClassName == e.overriddenDataClassName && current.useExistingDartClass == e.useExistingDartClass, e); } @override void visitNamedVariable(ColonNamedVariable e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitNullLiteral(NullLiteral e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitNumberedVariable(NumberedVariable e, void arg) { final current = _currentAs(e); _assert(current.explicitIndex == e.explicitIndex, e); _checkChildren(e); } @override void visitNumericLiteral(NumericLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value, e); _checkChildren(e); } @override void visitOrderBy(OrderBy e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitOrderingTerm(OrderingTerm e, void arg) { final current = _currentAs(e); _assert( current.orderingMode == e.orderingMode && current.nulls == e.nulls, e); _checkChildren(e); } @override void visitParentheses(Parentheses e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitRaiseExpression(RaiseExpression e, void arg) { final current = _currentAs(e); _assert( current.raiseKind == e.raiseKind && current.errorMessage == e.errorMessage, e, ); _checkChildren(e); } @override void visitReference(Reference e, void arg) { final current = _currentAs(e); _assert( current.schemaName == e.schemaName && current.entityName == e.entityName && current.columnName == e.columnName, e); _checkChildren(e); } @override void visitReturning(Returning e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitSelectInsertSource(SelectInsertSource e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitSelectStatement(SelectStatement e, void arg) { final current = _currentAs(e); _assert(current.distinct == e.distinct, e); _checkChildren(e); } @override void visitSelectStatementAsSource(SelectStatementAsSource e, void arg) { final current = _currentAs(e); _assert(current.as == e.as, e); _checkChildren(e); } @override void visitSetComponent(SetComponent e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitStarFunctionParameter(StarFunctionParameter e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitStarResultColumn(StarResultColumn e, void arg) { final current = _currentAs(e); _assert(current.tableName == e.tableName, e); _checkChildren(e); } @override void visitStringComparison(StringComparisonExpression e, void arg) { final current = _currentAs(e); _assert(current.not == e.not, e); _checkChildren(e); } @override void visitStringLiteral(StringLiteral e, void arg) { final current = _currentAs(e); _assert(current.value == e.value, e); _checkChildren(e); } @override void visitSubQuery(SubQuery e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitTableConstraint(TableConstraint e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && e.constraintEquals(current), e); _checkChildren(e); } @override void visitTableReference(TableReference e, void arg) { final current = _currentAs(e); _assert( current.schemaName == e.schemaName && current.tableName == e.tableName && current.as == e.as, e); _checkChildren(e); } @override void visitTableValuedFunction(TableValuedFunction e, void arg) { final current = _currentAs(e); _assert(current.name == e.name, e); _checkChildren(e); } @override void visitTimeConstantLiteral(TimeConstantLiteral e, void arg) { final current = _currentAs(e); _assert(current.kind == e.kind, e); _checkChildren(e); } @override void visitTuple(Tuple e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUnaryExpression(UnaryExpression e, void arg) { final current = _currentAs(e); _assert(current.operator.type == e.operator.type, e); _checkChildren(e); } @override void visitUpdateStatement(UpdateStatement e, void arg) { final current = _currentAs(e); _assert(current.or == e.or, e); _checkChildren(e); } @override void visitUpdateTriggerTarget(UpdateTarget e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUpsertClause(UpsertClause e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitUpsertClauseEntry(UpsertClauseEntry e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitValuesSelectStatement(ValuesSelectStatement e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitValuesSource(ValuesSource e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitWhen(WhenComponent e, void arg) { _currentAs(e); _checkChildren(e); } @override void visitWindowFunctionInvocation(WindowFunctionInvocation e, void arg) { final current = _currentAs(e); _assert(current.name == e.name && current.windowName == e.windowName, e); _checkChildren(e); } @override void visitWindowDefinition(WindowDefinition e, void arg) { final current = _currentAs(e); _assert(current.baseWindowName == e.baseWindowName, e); _checkChildren(e); } @override void visitWithClause(WithClause e, void arg) { final current = _currentAs(e); _assert(current.recursive == e.recursive, e); _checkChildren(e); } void _assert(bool contentEqual, AstNode context) { if (!contentEqual) _notEqual(context); } void _check(AstNode? childOfCurrent, AstNode? childOfOther) { if (identical(childOfCurrent, childOfOther)) return; if ((childOfCurrent == null) != (childOfOther == null)) { throw NotEqualException('$childOfCurrent and $childOfOther'); } // Both non nullable here final savedCurrent = _current; _current = childOfCurrent!; visit(childOfOther!, null); _current = savedCurrent; } void _checkChildren(AstNode other) { if (!_considerChildren) return; final currentChildren = _current.childNodes.iterator; final otherChildren = other.childNodes.iterator; while (currentChildren.moveNext()) { if (otherChildren.moveNext()) { _check(currentChildren.current, otherChildren.current); } else { // Current has more elements than other throw NotEqualException( "$_current and $other don't have an equal amount of children"); } } if (otherChildren.moveNext()) { // Other has more elements than current throw NotEqualException( "$_current and $other don't have an equal amount of children"); } } T _currentAs(T context) { final current = _current; if (current is T) return current; _notEqual(context); } Never _notEqual(AstNode other) { throw NotEqualException('$_current and $other'); } } /// Thrown by the [EqualityEnforcingVisitor] when two nodes were determined to /// be non-equal. class NotEqualException implements Exception { final String message; NotEqualException(this.message); @override String toString() { return 'Not equal: $message'; } } lib/src/utils/meta.dart 644 0 0 1416 14000111271 13146 0ustar0 pubpub/// Mixin for types that can have arbitrary metadata on them. mixin HasMetaMixin { final Map _metadata = {}; /// Returns the metadata of type [T] that might have been set on this node, or /// null if none was found. /// Nodes can have arbitrary annotations on them set via [setMeta] and /// obtained via [meta]. This mechanism is used to, for instance, attach /// variable scopes to a subtree. T? meta() { return _metadata[T] as T?; } /// Sets the metadata of type [T] to the specified [value]. /// Nodes can have arbitrary annotations on them set via [setMeta] and /// obtained via [meta]. This mechanism is used to, for instance, attach /// variable scopes to a subtree. void setMeta(T value) { _metadata[T] = value; } } lib/src/engine/autocomplete/suggestion.dart 644 0 0 1754 13764474313 17253 0ustar0 pubpubpart of 'engine.dart'; /// The result of suggesting auto-complete at a specific location. class ComputedSuggestions { /// The offset from the source file from which the suggestion should be /// applied. Effectively, the range from [anchor] to `anchor + lengthBefore` /// will be replaced with the suggestion. final int anchor; /// The amount of chars that have already been typed and would be replaced /// when applying a suggestion. final int lengthBefore; /// The actual suggestions which are relevant here. final List suggestions; ComputedSuggestions(this.anchor, this.lengthBefore, this.suggestions); } /// A single auto-complete suggestion. class Suggestion { /// The code inserted. final String code; /// The relevance of this suggestion, where more relevant suggestions have a /// higher [relevance]. final int relevance; Suggestion(this.code, this.relevance); @override String toString() { return 'Suggestion($code, $relevance)'; } } lib/src/engine/autocomplete/descriptions/description.dart 644 0 0 2436 13764474313 22113 0ustar0 pubpubpart of '../engine.dart'; /// Attached to a hint. A [HintDescription], together with additional context, /// can be used to compute the available autocomplete suggestions. abstract class HintDescription { const HintDescription(); const factory HintDescription.tokens(List types) = TokensDescription; factory HintDescription.token(TokenType type) = TokensDescription.single; Iterable suggest(CalculationRequest request); HintDescription mergeWith(HintDescription other) { return CombinedDescription() ..descriptions.add(this) ..descriptions.add(other); } } /// A [HintDescription] that bundles multiple independent [HintDescription]s. class CombinedDescription extends HintDescription { /// The descriptions to consult when using [suggest]. This list may be /// modified at runtime. final List descriptions = []; @override Iterable suggest(CalculationRequest request) { return descriptions.expand((s) => s.suggest(request)); } @override HintDescription mergeWith(HintDescription other) { if (other is CombinedDescription) { // optimization: flatten into single list descriptions.addAll(other.descriptions); } else { descriptions.add(other); } return this; } } lib/src/engine/autocomplete/descriptions/static.dart 644 0 0 1031 13764474313 21045 0ustar0 pubpubpart of '../engine.dart'; /// Suggestion that just inserts a bunch of token types with whitespace in /// between. class TokensDescription extends HintDescription { final List types; const TokensDescription(this.types); TokensDescription.single(TokenType type) : types = [type]; @override Iterable suggest(CalculationRequest request) sync* { final code = types .map((type) => reverseKeywords[type]) .where((k) => k != null) .join(' '); yield Suggestion(code, 0); } } lib/src/engine/autocomplete/descriptions/references.dart 644 0 0 630 13764474313 21663 0ustar0 pubpubpart of '../engine.dart'; /// Autocomplete hint to signal that a table name is expected. class TableNameDescription extends HintDescription { const TableNameDescription(); @override Iterable suggest(CalculationRequest request) { final tableNames = request.engine.knownResultSets.map((t) => t.escapedName); return tableNames.map((t) { return Suggestion(t, 1); }); } } lib/src/engine/autocomplete/engine.dart 644 0 0 7206 14155120333 16310 0ustar0 pubpubimport 'package:collection/collection.dart'; import 'package:sqlparser/sqlparser.dart'; part 'descriptions/description.dart'; part 'descriptions/references.dart'; part 'descriptions/static.dart'; part 'suggestion.dart'; /// Helper to provide context aware auto-complete suggestions inside a sql /// query. /// /// While parsing a query, the parser will yield a bunch of [Hint]s that are /// specific to a specific location. Each hint contains the current position and /// a [HintDescription] of what can appear behind that position. /// To obtain suggestions for a specific cursor position, we then go back from /// that position to the last [Hint] found and populate it. class AutoCompleteEngine { /// The found hints. UnmodifiableListView get foundHints => _hintsView; // hints are always sorted by their offset final List _hints = []; late final UnmodifiableListView _hintsView = UnmodifiableListView(_hints); final List _tokens; final SqlEngine _engine; void addHint(Hint hint) { if (_hints.isEmpty) { _hints.add(hint); } else { // ensure that the hints list stays sorted by offset final position = _lastHintBefore(hint.offset); final hintBefore = _hints[position]; // if we already have a hint at this position, merge them together if (hintBefore.before == hint.before) { hintBefore.description = hintBefore.description.mergeWith(hint.description); } else { _hints.insert(position + 1, hint); } } } AutoCompleteEngine(this._tokens, this._engine); /// Suggest completions at a specific [offset]. /// /// If the caller knows that autocomplete is requested in a CRUD statement /// that has been analyzed, providing the surrounding [context] can yield /// better results (for instance when completing column names). ComputedSuggestions suggestCompletions(int offset, [AnalysisContext? context]) { if (_hints.isEmpty) { return ComputedSuggestions(-1, -1, []); } final hint = foundHints[_lastHintBefore(offset)]; final suggestions = hint.description.suggest(CalculationRequest(_engine, context)).toList(); // when calculating the offset, respect whitespace that comes after the // last hint. final lastToken = hint.before; final nextToken = lastToken != null ? _tokens[lastToken.index + 1] : _tokens.first; final hintOffset = nextToken.span.start.offset; final length = offset - hintOffset; return ComputedSuggestions(hintOffset, length, suggestions); } /// find the last hint that appears before [offset] int _lastHintBefore(int offset) { var min = 0; var max = foundHints.length - 1; while (min < max) { final mid = min + ((max - min) >> 1); final hint = _hints[mid]; final offsetOfMid = hint.offset; if (offsetOfMid == offset) { return mid; } else { final offsetOfNext = _hints[mid + 1].offset; if (offsetOfMid < offset) { if (offsetOfNext > offset) { // next one is too late, so this must be the correct one return mid; } min = mid + 1; } else { max = mid - 1; } } } return min; } } class Hint { /// The token that appears just before this hint, or `null` if the hint /// appears at the beginning of the file. final Token? before; int get offset => before?.span.end.offset ?? 0; HintDescription description; Hint(this.before, this.description); } class CalculationRequest { final SqlEngine engine; final AnalysisContext? context; CalculationRequest(this.engine, [this.context]); } lib/src/engine/options.dart 644 0 0 11143 14206505067 14060 0ustar0 pubpubimport 'package:meta/meta.dart'; import 'package:sqlparser/sqlparser.dart'; class EngineOptions { /// Drift extends the sql grammar a bit to support type converters and other /// features. Enabling this flag will make this engine parse sql with these /// extensions enabled. final bool useDriftExtensions; /// The target sqlite version. /// /// The library will report when using sqlite features that were added after /// the desired [version]. /// Defaults to [SqliteVersion.minimum]. final SqliteVersion version; /// All [Extension]s that have been enabled in this sql engine. final List enabledExtensions; final List _addedFunctionHandlers = []; /// A map from lowercase function names to the associated handler. final Map addedFunctions = {}; /// A map from lowercase function names (where the function is a table-valued /// function) to the associated handler. final Map addedTableFunctions = {}; EngineOptions({ this.useDriftExtensions = false, List enabledExtensions = const [], this.version = SqliteVersion.minimum, }) : enabledExtensions = _allExtensions(enabledExtensions, version) { if (version < SqliteVersion.minimum) { throw ArgumentError.value( version, 'version', 'Must at least be ${SqliteVersion.minimum}'); } if (version > SqliteVersion.current) { throw ArgumentError.value( version, 'version', 'Must at most be ${SqliteVersion.current}'); } } static List _allExtensions( List added, SqliteVersion version) { return [ // The json1 extension was enabled by default in sqlite3 version 3.38, so // add it if it's not already enabled. if (version >= SqliteVersion.v3_38 && !added.any((e) => e is Json1Extension)) const Json1Extension(), ...added, ]; } void addFunctionHandler(FunctionHandler handler) { _addedFunctionHandlers.add(handler); for (final function in handler.functionNames) { addedFunctions[function.toLowerCase()] = handler; } } void addTableValuedFunctionHandler(TableValuedFunctionHandler handler) { addedTableFunctions[handler.functionName.toLowerCase()] = handler; } } /// The assumed version of `sqlite3`. /// /// This library can provide analysis hints when using sqlite features newer /// than the desired version. @sealed class SqliteVersion implements Comparable { /// The minimum sqlite version assumed by the current version of the /// `sqlparser` package. /// /// This does not mean that older version aren't supported, but this library /// can't provide analysis warnings when using recent sqlite3 features. static const SqliteVersion minimum = SqliteVersion.v3(34); /// Version `3.38.0` of `sqlite3`. static const SqliteVersion v3_38 = SqliteVersion.v3(38); /// Version `3.37.0` of `sqlite3`. static const SqliteVersion v3_37 = SqliteVersion.v3(37); /// Version `3.35.0` of `sqlite3`. static const SqliteVersion v3_35 = SqliteVersion.v3(35); /// The highest sqlite version supported by this `sqlparser` package. /// /// Newer features in `sqlite3` may not be recognized by this library. static const SqliteVersion current = v3_38; /// The major version of sqlite. /// /// This will always be `3` in the foreseeable future. final int major; /// The minor version of sqlite. /// /// sqlite version `3.34.0` would have a minor version of `34`. final int minor; /// The patch version of sqlite. /// /// sqlite version `3.34.1` would have a minor version of `1`. final int patch; const SqliteVersion(this.major, this.minor, this.patch); const SqliteVersion.v3(int minor, [int patch = 0]) : this(3, minor, patch); bool operator <(SqliteVersion other) => compareTo(other) < 0; bool operator >(SqliteVersion other) => compareTo(other) > 0; bool operator >=(SqliteVersion other) => compareTo(other) >= 0; @override int compareTo(SqliteVersion other) { if (major != other.major) return major.compareTo(other.major); if (minor != other.minor) return minor.compareTo(other.minor); if (patch != other.patch) return patch.compareTo(other.patch); return 0; } @override int get hashCode => major * minor * patch; @override bool operator ==(Object other) { return identical(this, other) || other is SqliteVersion && other.major == major && other.minor == minor && other.patch == patch; } @override String toString() { return 'SqliteVersion($major, $minor, $patch)'; } } lib/src/engine/module/module.dart 644 0 0 10273 14025064205 15133 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; /// Interface for sqlite extensions providing additional functions or module. /// /// Extension support in the sqlparser package is still experimental, and only /// supports modules for `CREATE VIRTUAL TABLE` statements at the moment. abstract class Extension { void register(SqlEngine engine); } /// Function handlers can be implemented by an [Extension] to add type analysis /// for additional function. abstract class FunctionHandler { /// Constant default constructor to allow const implementations. const FunctionHandler(); /// The set of function names supported by this handler. /// /// The returned set shouldn't change over time. Set get functionNames; /// Resolve the return type of a function invocation. /// /// The [call] refers to a function declared in [functionNames]. To provide /// further analysis, the [context] may be used. To support function calls /// with a [StarFunctionParameter], [expandedArgs] contains the expanded /// arguments from a `function(*)` call. /// /// If resolving to a type isn't possible, implementations should return /// [ResolveResult.unknown]. ResolveResult inferReturnType( AnalysisContext context, SqlInvocation call, List expandedArgs); /// Resolve the type of an argument used in a function invocation. /// /// The [call] refers to a function declared in [functionNames]. To provide /// further analysis, the [context] may be used. This method should return /// the inferred type of [argument], which is an argument passed to the /// [call]. /// /// If resolving to a type isn't possible, implementations should return /// [ResolveResult.unknown]. ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument); /// Can optionally be used by implementations to provide [AnalysisError]s /// from the [call]. /// /// Errors should be reported via [AnalysisContext.reportError]. void reportErrors(SqlInvocation call, AnalysisContext context) {} } /// Should be mixed on on [FunctionHandler] implementations only. mixin ArgumentCountLinter { /// Returns the amount of arguments expected for [function] (lowercase). /// /// If the function is unknown, or if the result would be ambiguous, returns /// null. int? argumentCountFor(String function); int actualArgumentCount(SqlInvocation call) { return call.expandParameters().length; } void reportMismatches(SqlInvocation call, AnalysisContext context) { final expectedArgs = argumentCountFor(call.name.toLowerCase()); if (expectedArgs != null) { final actualArgs = actualArgumentCount(call); if (actualArgs != expectedArgs) { reportArgumentCountMismatch(call, context, expectedArgs, actualArgs); } } } void reportArgumentCountMismatch( SqlInvocation call, AnalysisContext context, int? expected, int actual) { context.reportError(AnalysisError( relevantNode: call, message: '${call.name} expects $expected arguments, ' 'got $actual.', type: AnalysisErrorType.other, )); } } /// Interface for a handler which can resolve the result set of a table-valued /// function. abstract class TableValuedFunctionHandler { /// The name of the table-valued function implemented by this handler. String get functionName; /// Resolve the result set of a table-valued function. /// /// Should return null when the result set can't be resolved. /// /// See also: /// - https://www.sqlite.org/vtab.html#tabfunc2 ResultSet resolveTableValued( AnalysisContext context, TableValuedFunction call); } /// An sqlite module, which can be used in a `CREATE VIRTUAL TABLE` statement /// to find providers. abstract class Module implements Referencable { /// The name of this module, which is referenced by the `USING` clause in a /// `CREATE VIRTUAL TABLE` statement. final String name; Module(this.name); /// Extracts the table structure from a `CREATE VIRTUAL TABLE` statement that /// refers to this module. The module is responsible for setting /// [Table.definition]. Table parseTable(CreateVirtualTableStatement stmt); @override bool get visibleToChildren => true; } lib/src/engine/module/fts5.dart 644 0 0 13257 14131303604 14531 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class Fts5Extension implements Extension { const Fts5Extension(); @override void register(SqlEngine engine) { engine.registerModule(_Fts5Module()); engine.registerFunctionHandler(const _Fts5Functions()); } } /// FTS5 module for `CREATE VIRTUAL TABLE USING fts5` support class _Fts5Module extends Module { _Fts5Module() : super('fts5'); @override Table parseTable(CreateVirtualTableStatement stmt) { // arguments with an equals sign are parameters passed to the fts5 module. // they're not part of the schema. final columnNames = stmt.argumentContent.where((arg) => !arg.contains('=')).map((c) { // actual syntax is return c.trim().split(' ').first; }); return _Fts5Table( name: stmt.tableName, columns: [ for (var arg in columnNames) TableColumn(arg, const ResolvedType(type: BasicType.text)), ], definition: stmt, ); } } class _Fts5Table extends Table { _Fts5Table( {required String name, required List columns, CreateVirtualTableStatement? definition}) : super( name: name, resolvedColumns: [ ...columns, _Fts5RankColumn(), _Fts5TableColumn(name), ], definition: definition, isVirtual: true, ); } /// Provides type inference and lints for class _Fts5Functions with ArgumentCountLinter implements FunctionHandler { const _Fts5Functions(); @override Set get functionNames => const {'bm25', 'highlight', 'snippet'}; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { int? argumentIndex; if (call.parameters is ExprFunctionParameters) { argumentIndex = (call.parameters as ExprFunctionParameters) .parameters .indexOf(argument); } if (argumentIndex == null || argumentIndex < 0) { // couldn't find expression in arguments, so we don't know the type return const ResolveResult.unknown(); } switch (call.name) { case 'bm25': // bm25(fts_table) return const ResolveResult.unknown(); case 'highlight': // highlight(fts_table, column_index, text_before, text_after) if (argumentIndex == 1) { return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (argumentIndex == 2 || argumentIndex == 3) { return const ResolveResult(ResolvedType(type: BasicType.text)); } break; case 'snippet': // snippet(fts_table, column_index, phrase_before, phrase_after, // text_before, max_tokens) if (argumentIndex == 1 || argumentIndex == 5) { return const ResolveResult(ResolvedType(type: BasicType.int)); } else if (argumentIndex >= 2 || argumentIndex <= 4) { return const ResolveResult(ResolvedType(type: BasicType.text)); } break; } return const ResolveResult.unknown(); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { switch (call.name) { case 'bm25': return const ResolveResult(ResolvedType(type: BasicType.real)); case 'highlight': return const ResolveResult(ResolvedType(type: BasicType.text)); case 'snippet': return const ResolveResult(ResolvedType(type: BasicType.text)); } return const ResolveResult.unknown(); } @override int? argumentCountFor(String function) { return const { 'bm25': 1, 'highlight': 4, 'snippet': 6, }[function]; } @override void reportErrors(SqlInvocation call, AnalysisContext context) { // it doesn't make sense to call fts5 functions with a star parameter if (call.parameters is StarFunctionParameter) { context.reportError(AnalysisError( relevantNode: call, message: '${call.name} should not be called with a star parameter', type: AnalysisErrorType.other, )); return; } final args = (call.parameters as ExprFunctionParameters).parameters; final expectedArgCount = argumentCountFor(call.name.toLowerCase()); if (expectedArgCount != args.length) { reportArgumentCountMismatch(call, context, expectedArgCount, args.length); return; } Column? firstResolved; if (args.first is Reference) { firstResolved = (args.first as Reference).resolvedColumn; } // the first argument to all functions must be a fts5 table name if (firstResolved == null || firstResolved.source is! _Fts5TableColumn) { context.reportError(AnalysisError( relevantNode: args.first, message: 'Expected an fts5 table name here', type: AnalysisErrorType.other, )); } } } /// The rank column, which we introduce to support queries like /// ``` /// SELECT * FROM my_fts_table WHERE my_fts_table MATCH 'foo' ORDER BY rank; /// ``` class _Fts5RankColumn extends TableColumn { @override bool get includedInResults => false; _Fts5RankColumn() : super('rank', const ResolvedType(type: BasicType.real, nullable: true)); } /// A column that has the same name as the fts5 it's from. We introduce this /// column to support constructs like /// ``` /// CREATE VIRTUAL TABLE foo USING fts5(bar, baz); /// query: SELECT * FROM foo WHERE foo MATCH 'something'; /// ``` /// The easiest way to support that is to just make "foo" a column on that /// table. class _Fts5TableColumn extends TableColumn { @override bool get includedInResults => false; _Fts5TableColumn(String name) : super(name, const ResolvedType(type: BasicType.text)); } lib/src/engine/module/math.dart 644 0 0 6136 14155120333 14561 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/engine/options.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'module.dart'; /// A math extension providing functions built into sqlite. /// /// This is an extension since it's only available when sqlite 3.35 is used /// together with the `-DSQLITE_ENABLE_MATH_FUNCTIONS` compile-time option. class BuiltInMathExtension implements Extension { const BuiltInMathExtension(); @override void register(SqlEngine engine) { if (engine.options.version < SqliteVersion.v3_35) { throw StateError('The math extension is only available with ' 'sqlite3 version 35 or later'); } engine.registerFunctionHandler(const _MathFunctions()); } } class _MathFunctions extends FunctionHandler { const _MathFunctions(); static const _constants = { 'pi', }; static const _unary = { 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'degrees', 'exp', 'ln', 'log', // note that log is also binary 'log10', 'log2', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', }; static const _unaryToInt = { 'ceil', 'ceiling', 'floor', 'trunc', }; static const _binary = { 'atan2', 'pow', 'power', 'mod', }; @override Set get functionNames => const {..._constants, ..._unary, ..._unaryToInt, ..._binary}; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { return const ResolveResult(ResolvedType(type: BasicType.real)); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { if (_unaryToInt.contains(call.name.toLowerCase())) { return const ResolveResult(ResolvedType(type: BasicType.int)); } return const ResolveResult(ResolvedType(type: BasicType.real)); } @override void reportErrors(SqlInvocation call, AnalysisContext context) { final name = call.name.toLowerCase(); final argumentCount = call.expandParameters().length; // log can be called with one or two arguments if (name == 'log') { if (argumentCount != 1 && argumentCount != 2) { context.reportError(AnalysisError( relevantNode: call, message: 'log requires one or two arguments, got $argumentCount', type: AnalysisErrorType.other, )); } return; } int expectedArgs; if (_constants.contains(name)) { expectedArgs = 0; } else if (_unary.contains(name) || _unaryToInt.contains(name)) { expectedArgs = 1; } else if (_binary.contains(name)) { expectedArgs = 2; } else { return; // Can't say how many args are required } if (expectedArgs != argumentCount) { context.reportError(AnalysisError( relevantNode: call, message: '$name requires $expectedArgs arguments, got $argumentCount', type: AnalysisErrorType.other, )); } } } lib/src/engine/module/json1.dart 644 0 0 6262 13764474313 14701 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; class Json1Extension implements Extension { const Json1Extension(); @override void register(SqlEngine engine) { engine ..registerFunctionHandler(const _Json1Functions()) ..registerTableValuedFunctionHandler(const _JsonEachFunction()) ..registerTableValuedFunctionHandler(const _JsonTreeFunction()); } } class _Json1Functions implements FunctionHandler { const _Json1Functions(); static const Set _returnStrings = { 'json', 'json_array', 'json_insert', 'json_replace', 'json_set', 'json_object', 'json_patch', 'json_remove', 'json_quote', 'json_group_array', 'json_group_object', }; @override Set get functionNames => const { ..._returnStrings, 'json_type', 'json_valid', 'json_extract', 'json_array_length', }; @override ResolveResult inferArgumentType( AnalysisContext context, SqlInvocation call, Expression argument) { return const ResolveResult.unknown(); } @override ResolveResult inferReturnType(AnalysisContext context, SqlInvocation call, List expandedArgs) { final name = call.name.toLowerCase(); if (_returnStrings.contains(name)) { return const ResolveResult(ResolvedType(type: BasicType.text)); } else { switch (name) { case 'json_type': return const ResolveResult( ResolvedType(type: BasicType.text, nullable: true)); case 'json_valid': return const ResolveResult(ResolvedType.bool()); case 'json_extract': return const ResolveResult.unknown(); case 'json_array_length': return const ResolveResult(ResolvedType(type: BasicType.int)); } } throw AssertionError("Can't happen, unknown json1 function"); } @override void reportErrors(SqlInvocation call, AnalysisContext context) {} } final _jsonFunctionResultSet = CustomResultSet([ // https://www.sqlite.org/json1.html#the_json_each_and_json_tree_table_valued_functions // we use string for any TableColumn('key', const ResolvedType(type: BasicType.text)), TableColumn( 'value', const ResolvedType(type: BasicType.text, nullable: true)), TableColumn('type', const ResolvedType(type: BasicType.text)), TableColumn('atom', const ResolvedType(type: BasicType.text)), TableColumn('type', const ResolvedType(type: BasicType.text)), TableColumn('id', const ResolvedType(type: BasicType.int)), TableColumn( 'parent', const ResolvedType(type: BasicType.int, nullable: true)), TableColumn('fullkey', const ResolvedType(type: BasicType.text)), ]); abstract class _JsonTableValuedFunction implements TableValuedFunctionHandler { const _JsonTableValuedFunction(); @override ResultSet resolveTableValued( AnalysisContext context, TableValuedFunction call) { return _jsonFunctionResultSet; } } class _JsonEachFunction extends _JsonTableValuedFunction { const _JsonEachFunction(); @override String get functionName => 'json_each'; } class _JsonTreeFunction extends _JsonTableValuedFunction { const _JsonTreeFunction(); @override String get functionName => 'json_tree'; } lib/src/engine/builtin_tables.dart 644 0 0 1645 13764474313 15362 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; /// Constructs the "sqlite_sequence" table. Table get sqliteSequence { final name = TableColumn('name', const ResolvedType(type: BasicType.text)); final seq = TableColumn('seq', const ResolvedType(type: BasicType.int)); return Table(name: 'sqlite_sequence', resolvedColumns: [name, seq]); } /// Constructs the "sqlite_master" table Table get sqliteMaster { final type = TableColumn('type', const ResolvedType(type: BasicType.text)); final name = TableColumn('name', const ResolvedType(type: BasicType.text)); final tblName = TableColumn('tbl_name', const ResolvedType(type: BasicType.text)); final rootPage = TableColumn('rootpage', const ResolvedType(type: BasicType.int)); final sql = TableColumn('sql', const ResolvedType(type: BasicType.text)); return Table( name: 'sqlite_master', resolvedColumns: [type, name, tblName, rootPage, sql], ); } lib/src/engine/sql_engine.dart 644 0 0 24311 14206506564 14515 0ustar0 pubpubimport 'dart:collection'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'autocomplete/engine.dart'; import 'builtin_tables.dart'; class SqlEngine { /// All tables registered with [registerTable]. final List knownResultSets = []; final List _knownModules = []; /// Internal options for this sql engine. final EngineOptions options; SchemaFromCreateTable? _schemaReader; SqlEngine([EngineOptions? engineOptions]) : options = engineOptions ?? EngineOptions() { for (final extension in options.enabledExtensions) { extension.register(this); } registerTable(sqliteMaster); registerTable(sqliteSequence); } /// Obtain a [SchemaFromCreateTable] instance compatible with the /// configuration of this engine. /// /// The returned reader can be used to read the table structure from a /// [TableInducingStatement] by using [SchemaFromCreateTable.read]. SchemaFromCreateTable get schemaReader { return _schemaReader ??= SchemaFromCreateTable(driftExtensions: options.useDriftExtensions); } /// Registers the [table], which means that it can later be used in sql /// statements. void registerTable(Table table) { registerResultSet(table); } /// Registers the [view], which means that it can later be used in sql /// statements. void registerView(View view) { registerResultSet(view); } /// Registers an arbitrary [namedResultSet], which means that it can later /// be used in sql statements. void registerResultSet(NamedResultSet namedResultSet) { knownResultSets.add(namedResultSet); } /// Registers the [module], which means that it can be used as a function in /// `CREATE VIRTUAL TABLE` statements. void registerModule(Module module) { _knownModules.add(module); } /// Registers the [handler], which can provide implementations for additional /// sql functions that can then be used in statements analyzed through this /// engine. void registerFunctionHandler(FunctionHandler handler) { options.addFunctionHandler(handler); } /// Registers the [handler], which can infer result sets for a table-valued /// function. void registerTableValuedFunctionHandler(TableValuedFunctionHandler handler) { options.addTableValuedFunctionHandler(handler); } ReferenceScope _constructRootScope({ReferenceScope? parent}) { final scope = parent == null ? ReferenceScope(null) : parent.createChild(); for (final resultSet in knownResultSets) { scope.register(resultSet.name, resultSet); } for (final module in _knownModules) { scope.register(module.name, module); } return scope; } /// Tokenizes the [source] into a list list [Token]s. Each [Token] contains /// information about where it appears in the [source] and a [TokenType]. /// /// Note that the list might be tokens that should be /// [Token.invisibleToParser], if you're passing them to a [Parser] directly, /// you need to filter them. When using the methods in this class, this will /// be taken care of automatically. List tokenize(String source) { final scanner = Scanner(source, scanDriftTokens: options.useDriftExtensions); final tokens = scanner.scanTokens(); return tokens; } /// Parses a single [sql] statement into an AST-representation. ParseResult parse(String sql) { final tokens = tokenize(sql); final tokensForParser = tokens.where((t) => !t.invisibleToParser).toList(); final parser = Parser(tokensForParser, useDrift: options.useDriftExtensions); final stmt = parser.safeStatement(); return ParseResult._(stmt, tokens, parser.errors, sql, null); } /// Parses a `.drift` file, which can consist of multiple statements and /// additional components like import statements. ParseResult parseDriftFile(String content) { assert(options.useDriftExtensions); final tokens = tokenize(content); final autoComplete = AutoCompleteEngine(tokens, this); final tokensForParser = tokens.where((t) => !t.invisibleToParser).toList(); final parser = Parser(tokensForParser, useDrift: true, autoComplete: autoComplete); final driftFile = parser.driftFile(); _attachRootScope(driftFile); return ParseResult._( driftFile, tokens, parser.errors, content, autoComplete); } /// Parses and analyzes the [sql] statement. The [AnalysisContext] returned /// contains all information about type hints, errors, and the parsed AST. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyze(String sql, {AnalyzeStatementOptions? stmtOptions}) { final result = parse(sql); final analyzed = analyzeParsed(result, stmtOptions: stmtOptions); // Add parsing errors that occurred at the beginning since they are the most // prominent problems. analyzed.errors .insertAll(0, result.errors.map((e) => AnalysisError.fromParser(e))); return analyzed; } /// Analyzes a parsed [result] statement. The [AnalysisContext] returned /// contains all information about type hints, errors, and the parsed AST. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyzeParsed(ParseResult result, {AnalyzeStatementOptions? stmtOptions}) { final node = result.rootNode; final context = _createContext(node, result.sql, stmtOptions); _analyzeContext(context); return context; } /// Analyzes the given [node], which should be a [CrudStatement]. /// The [AnalysisContext] enhances the AST by reporting type hints and errors. /// The [file] should contain the full SQL source code that was used to parse /// the [node]. /// /// The analyzer needs to know all the available tables to resolve references /// and result columns, so all known tables should be registered using /// [registerTable] before calling this method. /// The [stmtOptions] can be used to pass additional options used to analyze /// this statement only. AnalysisContext analyzeNode(AstNode node, String file, {AnalyzeStatementOptions? stmtOptions}) { final context = _createContext(node, file, stmtOptions); _analyzeContext(context); return context; } AnalysisContext _createContext( AstNode node, String sql, AnalyzeStatementOptions? stmtOptions) { return AnalysisContext(node, sql, options, stmtOptions: stmtOptions, schemaSupport: schemaReader); } void _analyzeContext(AnalysisContext context) { final node = context.root; _attachRootScope(node); try { AstPreparingVisitor(context: context).start(node); node ..acceptWithoutArg(ColumnResolver(context)) ..acceptWithoutArg(ReferenceResolver(context)); final session = TypeInferenceSession(context, options); final resolver = TypeResolver(session); resolver.run(node); context.types2 = session.results!; node.acceptWithoutArg(LintingVisitor(options, context)); } catch (_) { rethrow; } } void _attachRootScope(AstNode root) { // calling node.referenceScope throws when no scope is set, we use the // nullable variant here final safeScope = root.selfAndParents .map((node) => node.meta()) .firstWhere((e) => e != null, orElse: () => null); root.scope = _constructRootScope(parent: safeScope); } } /// The result of parsing an sql query. Contains the root of the AST and all /// errors that might have occurred during parsing. class ParseResult { /// The topmost node in the sql AST that was parsed. final AstNode rootNode; /// The tokens that were scanned in the source file, including those that are /// [Token.invisibleToParser]. final List tokens; /// A list of all errors that occurred during parsing. [ParsingError.toString] /// returns a helpful description of what went wrong, along with the position /// where the error occurred. final List errors; /// The sql source that created the AST at [rootNode]. final String sql; /// The engine which can be used to handle auto-complete requests on this /// result. final AutoCompleteEngine? autoCompleteEngine; ParseResult._(this.rootNode, this.tokens, this.errors, this.sql, this.autoCompleteEngine) { const SetParentVisitor().startAtRoot(rootNode); } /// Attempts to find the most relevant (bottom-most in the AST) nodes that /// intersects with the source range from [offset] to [offset] + [length]. List findNodesAtPosition(int offset, {int length = 0}) { if (tokens.isEmpty) return const []; final candidates = {}; final unchecked = Queue(); unchecked.add(rootNode); while (unchecked.isNotEmpty) { final node = unchecked.removeFirst(); final span = node.span!; final start = span.start.offset; final end = span.end.offset; final hasIntersection = !(end < offset || start > offset + length); if (hasIntersection) { // this node matches. As we want to find the bottom-most node in the AST // that matches, this means that the parent is no longer a candidate. candidates.add(node); candidates.remove(node.parent); // assume that the span of a node is a superset of the span of any // child, so each child could potentially be interesting. unchecked.addAll(node.childNodes); } } return candidates.toList(); } /// Returns the lexeme that created an AST [node] (which should be a child of /// [rootNode], e.g appear in this result). String lexemeOfNode(AstNode node) { return sql.substring(node.firstPosition, node.lastPosition); } } LICENSE 644 0 0 2055 13506466600 7677 0ustar0 pubpubMIT License Copyright (c) 2019 Simon Binder Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. analysis_options.yaml 644 0 0 41 13744274200 13102 0ustar0 pubpubinclude: ../analysis_options.yamltest/analysis/data.dart 644 0 0 2074 14142037646 13263 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; final TableColumn id = TableColumn( 'id', const ResolvedType(type: BasicType.int), definition: ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [PrimaryKeyColumn(null)], ), ); final TableColumn content = TableColumn('content', const ResolvedType(type: BasicType.text)); final Table demoTable = Table( name: 'demo', resolvedColumns: [id, content], ); final TableColumn anotherId = TableColumn('id', const ResolvedType(type: BasicType.int)); final TableColumn dateTime = TableColumn( 'date', const ResolvedType(type: BasicType.int, hint: IsDateTime())); final Table anotherTable = Table( name: 'tbl', resolvedColumns: [anotherId, dateTime], ); extension RegisterTableExtension on SqlEngine { /// Utility function that parses a `CREATE TABLE` statement and registers the /// created table to the engine. void registerTableFromSql(String createTable) { final stmt = analyze(createTable).root as TableInducingStatement; registerTable(schemaReader.read(stmt)); } } test/analysis/reference_resolver_test.dart 644 0 0 23473 14211623631 17306 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; import 'data.dart'; void main() { test('correctly resolves return columns', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT id, d.content, *, 3 + 4 FROM demo AS d ' 'WHERE _rowid_ = 3'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(context.errors, isEmpty); expect(resolvedColumns.map((c) => c.name), ['id', 'content', 'id', 'content', '3 + 4']); expect(resolvedColumns.map((c) => context.typeOf(c).type!.type), [ BasicType.int, BasicType.text, BasicType.int, BasicType.text, BasicType.int, ]); final firstColumn = select.columns[0] as ExpressionResultColumn; final secondColumn = select.columns[1] as ExpressionResultColumn; final from = select.from as TableReference; expect((firstColumn.expression as Reference).resolvedColumn?.source, id); expect( (secondColumn.expression as Reference).resolvedColumn?.source, content); expect(from.resultSet?.unalias(), demoTable); final where = select.where as BinaryExpression; expect((where.left as Reference).resolved, id); }); test('resolves columns from views', () { final engine = SqlEngine()..registerTable(demoTable); final viewCtx = engine.analyze('CREATE VIEW my_view (foo, bar) AS ' 'SELECT * FROM demo;'); engine.registerView(engine.schemaReader .readView(viewCtx, viewCtx.root as CreateViewStatement)); final context = engine.analyze('SELECT * FROM my_view'); expect(context.errors, isEmpty); final resolvedColumns = (context.root as SelectStatement).resolvedColumns!; expect(resolvedColumns.map((e) => e.name), ['foo', 'bar']); expect( resolvedColumns.map((e) => context.typeOf(e).type!.type), [BasicType.int, BasicType.text], ); }); test("resolved columns don't include drift nested results", () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTable(demoTable); final context = engine.analyze('SELECT demo.** FROM demo;'); expect(context.errors, isEmpty); expect((context.root as SelectStatement).resolvedColumns, isEmpty); }); test('resolves the column for order by clauses', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine .analyze('SELECT d.content, 3 * d.id AS t FROM demo AS d ORDER BY t'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final term = (select.orderBy as OrderBy).terms.single as OrderingTerm; final expression = term.expression as Reference; final resolved = expression.resolved as ExpressionColumn; enforceEqual( resolved.expression, BinaryExpression( NumericLiteral(3, token(TokenType.numberLiteral)), token(TokenType.star), Reference(entityName: 'd', columnName: 'id'), ), ); }); test('resolves columns from nested results', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTable(demoTable) ..registerTable(anotherTable); final context = engine.analyze('SELECT SUM(*) AS rst FROM ' '(SELECT COUNT(*) FROM demo UNION ALL SELECT COUNT(*) FROM tbl);'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; expect(select.resolvedColumns, hasLength(1)); expect( context.typeOf(select.resolvedColumns!.single).type!.type, BasicType.int, ); }); test('resolves columns in nested queries', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTable(demoTable); final context = engine.analyze('SELECT content, LIST(SELECT id FROM demo) FROM demo'); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final nestedQuery = select.columns[1] as NestedQueryColumn; expect(nestedQuery.select.columns, hasLength(1)); expect( context.typeOf(nestedQuery.select.resolvedColumns!.single).type!.type, BasicType.int, ); }); group('reports correct column name for rowid aliases', () { final engine = SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); test('when virtual id', () { final context = engine.analyze('SELECT oid, _rowid_ FROM tbl'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(resolvedColumns.map((c) => c.name), ['rowid', 'rowid']); }); test('when alias to actual column', () { final context = engine.analyze('SELECT oid, _rowid_ FROM demo'); final select = context.root as SelectStatement; final resolvedColumns = select.resolvedColumns!; expect(resolvedColumns.map((c) => c.name), ['id', 'id']); }); }); test('resolves sub-queries', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze( 'SELECT d.*, (SELECT id FROM demo WHERE id = d.id) FROM demo d;'); expect(context.errors, isEmpty); }); test('resolves sub-queries as data sources', () { final engine = SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); final context = engine.analyze('SELECT d.* FROM demo d INNER JOIN tbl ' 'ON tbl.id = (SELECT id FROM tbl WHERE date = ? AND id = d.id)'); expect(context.errors, isEmpty); }); test('resolves window declarations', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' SELECT row_number() OVER wnd FROM demo WINDOW wnd AS (PARTITION BY content GROUPS CURRENT ROW EXCLUDE TIES) '''); final column = (context.root as SelectStatement).resolvedColumns!.single as ExpressionColumn; final over = (column.expression as WindowFunctionInvocation).over!; enforceEqual( over, WindowDefinition( partitionBy: [Reference(columnName: 'content')], frameSpec: FrameSpec( type: FrameType.groups, start: FrameBoundary.currentRow(), excludeMode: ExcludeMode.ties, ), ), ); }); test('warns about ambigious references', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT id FROM demo, (SELECT id FROM demo) AS a'); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having((e) => e.type, 'type', AnalysisErrorType.ambiguousReference) .having((e) => e.span?.text, 'span.text', 'id'), ); }); test("does not allow columns from tables that haven't been added", () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT demo.id;'); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having( (e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span?.text, 'span.text', 'demo.id')); }); group('nullability for references from outer join', () { final engine = SqlEngine() ..registerTableFromSql(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY ); ''') ..registerTableFromSql(''' CREATE TABLE messages ( sender INTEGER NOT NULL ); '''); void testWith(String sql) { final context = engine.analyze(sql); expect(context.errors, isEmpty); final columns = (context.root as SelectStatement).resolvedColumns!; expect(columns.map((e) => e.name), ['sender', 'id']); expect(context.typeOf(columns[0]).nullable, isFalse); expect(context.typeOf(columns[1]).nullable, isTrue); } test('unaliased columns, unaliased tables', () { testWith('SELECT sender, id FROM messages ' 'LEFT JOIN users ON id = sender'); }); test('unaliased columns, aliased tables', () { testWith('SELECT sender, id FROM messages m ' 'LEFT JOIN users u ON id = sender'); }); test('aliased columns, unaliased tables', () { testWith('SELECT messages.sender, users.id FROM messages ' 'LEFT JOIN users ON id = sender'); }); test('aliased columns, aliased tables', () { testWith('SELECT m.*, u.* FROM messages m ' 'LEFT JOIN users u ON u.id = m.sender'); }); test('single star, aliased tables', () { testWith('SELECT * FROM messages m ' 'LEFT JOIN users u ON u.id = m.sender'); }); test('single star, unaliased tables', () { testWith('SELECT * FROM messages ' 'LEFT JOIN users ON id = sender'); }); }); group('join analysis keeps column non-nullable', () { void testWith(String sql) { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTableFromSql(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY ); '''); final result = engine.analyze(sql); expect(result.errors, isEmpty); final root = result.root as StatementReturningColumns; expect( root.returnedResultSet!.resolvedColumns! .map((e) => result.typeOf(e).type), everyElement( isA().having((e) => e.nullable, 'nullable', isFalse)), ); } test('for reference to table in INSERT', () { testWith('INSERT INTO users VALUES (?) RETURNING id;'); }); test('for reference to table in UPDATE', () { testWith('UPDATE users SET id = id + 1 RETURNING id;'); }); test('for reference to table in DELETE', () { testWith('DELETE FROM users RETURNING id;'); }); }); } test/analysis/errors/compound_column_mismatch_test.dart 644 0 0 735 13661767503 22004 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('reports column count mismatch in compound select query', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo UNION SELECT 1'); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.compoundColumnCountMismatch); }); } test/analysis/errors/write_to_generated_column.dart 644 0 0 1413 14155120333 21077 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(); engine.registerTableFromSql(''' CREATE TABLE a ( ok TEXT NOT NULL, g TEXT GENERATED ALWAYS AS (ok) STORED ); '''); }); test('reports error when updating generated column', () { engine .analyze("UPDATE a SET ok = 'new', g = 'old';") .expectError('g', type: AnalysisErrorType.writeToGeneratedColumn); }); test('reports error when inserting generated column', () { engine .analyze('INSERT INTO a (ok, g) VALUES (?, ?)') .expectError('g', type: AnalysisErrorType.writeToGeneratedColumn); }); } test/analysis/errors/duplicate_primary_key_test.dart 644 0 0 2733 14014446300 21301 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { void check(String sql, List problems) { final engine = SqlEngine(); final parseResult = engine.parse(sql); engine.registerTable(const SchemaFromCreateTable() .read(parseResult.rootNode as CreateTableStatement)); final context = engine.analyzeParsed(parseResult); expect( context.errors, pairwiseCompare( problems, (span, err) => err.span?.text == span, 'with span', ), ); } test('not reported on a correct table', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT ); ''', [], ); }); test('multiple column constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT PRIMARY KEY, ); ''', ['PRIMARY KEY'], ); }); test('with column and table constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER PRIMARY KEY, bar TEXT, PRIMARY KEY (foo, bar) ); ''', ['PRIMARY KEY (foo, bar)'], ); }); test('multiple table constraints', () { check( ''' CREATE TABLE tbl ( foo INTEGER, bar TEXT, PRIMARY KEY (foo), PRIMARY KEY (bar) ); ''', ['PRIMARY KEY (bar)'], ); }); } test/analysis/errors/syntax_error_test.dart 644 0 0 7325 14200761154 17461 0ustar0 pubpub// tests for syntax errors revealed during static analysis. import 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { group('DO UPDATE clause without conflict target', () { test('is forbidden on older sqlite versions', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3;'); expect(result.errors, [ const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.synctactic) .having((e) => e.message, 'message', contains('Expected a conflict clause')) ]); }); test('is allowed on the last clause', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTable(demoTable); expect( engine .analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3;') .errors, isEmpty, ); }); test('is not allowed on previous clauses', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)) ..registerTable(demoTable); expect( engine .analyze('INSERT INTO demo VALUES (?, ?) ' 'ON CONFLICT DO UPDATE SET id = 3' 'ON CONFLICT DO NOTHING;') .errors, hasLength(1), ); }); }); test('complex expressions in PRIMARY KEY clause', () { final engine = SqlEngine(); final parseResult = engine.parse(''' CREATE TABLE tbl ( foo INTEGER NOT NULL, bar TEXT NOT NULL, PRIMARY KEY (foo DESC, bar || 'test') ); '''); engine.registerTable(const SchemaFromCreateTable() .read(parseResult.rootNode as CreateTableStatement)); final analyzeResult = engine.analyzeParsed(parseResult); expect(analyzeResult.errors, [ const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.synctactic) .having((e) => e.message, 'message', contains('Only column names can be used in a PRIMARY KEY clause')) ]); }); group('illegal constructs in triggers', () { final engine = SqlEngine()..registerTable(demoTable); test('DEFAULT VALUES', () { engine.analyze('INSERT INTO demo DEFAULT VALUES').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'INSERT INTO demo DEFAULT VALUES;' 'END;') .expectError('DEFAULT VALUES', type: AnalysisErrorType.synctactic); }); group('aliased source tables', () { test('insert', () { engine.analyze('INSERT INTO demo AS d VALUES (?, ?)').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'INSERT INTO demo AS d VALUES (?, ?);' 'END;') .expectError('demo AS d', type: AnalysisErrorType.synctactic); }); test('update', () { engine.analyze('UPDATE demo AS d SET id = id + 1;').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'UPDATE demo AS d SET id = id + 1;' 'END;') .expectError('demo AS d', type: AnalysisErrorType.synctactic); }); test('delete', () { engine.analyze('DELETE FROM demo d;').expectNoError(); engine .analyze('CREATE TRIGGER tgr AFTER DELETE ON demo BEGIN ' 'DELETE FROM demo d;' 'END;') .expectError('demo d', type: AnalysisErrorType.synctactic); }); }); }); } test/analysis/errors/unsupported_test.dart 644 0 0 6740 14205520454 17313 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; import 'utils.dart'; void main() { final minimumEngine = SqlEngine()..registerTable(demoTable); final currentEngine = SqlEngine(EngineOptions(version: SqliteVersion.current)) ..registerTable(demoTable); test('reports error for MATERIALIZED in CTEs', () { const sql = ''' WITH foo (x) AS MATERIALIZED (SELECT 1) SELECT 2; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA() .having((e) => e.message, 'message', contains('requires sqlite3 version 35')) .having((e) => e.span!.text, 'span.text', 'MATERIALIZED'), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for multiple ON CONFLICT clauses', () { const sql = ''' INSERT INTO demo VALUES (3, 'hi') ON CONFLICT (content) DO NOTHING ON CONFLICT (id) DO UPDATE SET content = 'reset'; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA().having((e) => e.message, 'message', contains('require sqlite version 3.35 or later')), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for RETURNING on unsupported errors', () { const sql = ''' UPDATE demo SET content = content || content RETURNING *; '''; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); expect( context.errors.single, isA().having((e) => e.message, 'message', 'RETURNING requires sqlite version 3.35 or later'), ); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('reports error for STRICT on an old sqlite3 version', () { const sql = 'CREATE TABLE a (b TEXT) STRICT'; final context = minimumEngine.analyze(sql); expect(context.errors, hasLength(1)); context.expectError('STRICT', type: AnalysisErrorType.notSupportedInDesiredVersion); expect(currentEngine.analyze(sql).errors, isEmpty); }); test('does not support `->` and `->>`in old sqlite3 versions', () { minimumEngine.analyze("SELECT '' -> ''").expectError('->', type: AnalysisErrorType.notSupportedInDesiredVersion); minimumEngine.analyze("SELECT '' ->> ''").expectError('->>', type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze("SELECT '' -> ''").expectNoError(); currentEngine.analyze("SELECT '' ->> ''").expectNoError(); }); test('warns about using `printf` after 3.38', () { const sql = "SELECT printf('', 0, 'foo')"; currentEngine .analyze(sql) .expectError("printf('', 0, 'foo')", type: AnalysisErrorType.hint); minimumEngine.analyze(sql).expectNoError(); }); test('warns about using unixepoch before 3.38', () { const sql = "SELECT unixepoch('')"; minimumEngine.analyze(sql).expectError("unixepoch('')", type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); test('warns about using format before 3.38', () { const sql = "SELECT format('', 0, 'foo')"; minimumEngine.analyze(sql).expectError("format('', 0, 'foo')", type: AnalysisErrorType.notSupportedInDesiredVersion); currentEngine.analyze(sql).expectNoError(); }); } test/analysis/errors/utils.dart 644 0 0 1216 14131303604 15007 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; extension ExpectErrors on AnalysisContext { void expectError(String lexeme, {AnalysisErrorType? type}) { expect( errors, [analysisErrorWith(lexeme: lexeme, type: type)], ); } void expectNoError() { expect(errors, isEmpty); } } Matcher analysisErrorWith({String? lexeme, AnalysisErrorType? type}) { var matcher = isA(); if (lexeme != null) { matcher = matcher.having((e) => e.span?.text, 'span.text', lexeme); } if (type != null) { matcher = matcher.having((e) => e.type, 'type', type); } return matcher; } test/analysis/errors/limit_or_order_by_in_compound_test.dart 644 0 0 2245 13764474313 23027 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error if LIMIT is used before last part', () { final engine = SqlEngine(); final analyzed = engine.analyze('SELECT 1 LIMIT 3 UNION SELECT 2'); expect(analyzed.errors, hasLength(1)); final error = analyzed.errors.single; expect(error.type, AnalysisErrorType.synctactic); final problematicSelect = (analyzed.root as CompoundSelectStatement).base; final wrongLimit = (problematicSelect as SelectStatement).limit; expect(error.relevantNode, wrongLimit); }); test('reports error if ORDER BY is used before last part', () { final engine = SqlEngine(); final analyzed = engine.analyze(''' SELECT 1 UNION SELECT 1 ORDER BY 2 INTERSECT SELECT 1 '''); expect(analyzed.errors, hasLength(1)); final error = analyzed.errors.single; expect(error.type, AnalysisErrorType.synctactic); final problematicSelect = (analyzed.root as CompoundSelectStatement).additional[0].select; final wrongOrderBy = (problematicSelect as SelectStatement).orderBy; expect(error.relevantNode, wrongOrderBy); }); } test/analysis/errors/all_columns_are_generated_test.dart 644 0 0 1407 14155120333 22067 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error if all columns are generated', () { final result = SqlEngine().analyze(''' CREATE TABLE a ( a TEXT GENERATED ALWAYS AS ('a'), b TEXT GENERATED ALWAYS AS ('b') ); '''); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.allColumnsAreGenerated); }); test('does not report an error if a non-generated column exists', () { final result = SqlEngine().analyze(''' CREATE TABLE a ( a TEXT GENERATED ALWAYS AS ('a'), b TEXT GENERATED ALWAYS AS ('b'), c TEXT ); '''); expect(result.errors, isEmpty); }); } test/analysis/errors/row_value_misuse_test.dart 644 0 0 3720 14131303604 20300 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(); }); test('when using row value in select', () { engine .analyze('SELECT (1, 2, 3)') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('as left hand operator of in', () { engine .analyze('SELECT (1, 2, 3) IN (4, 5, 6)') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in BETWEEN expression', () { engine .analyze('SELECT 1 BETWEEN (1, 2, 3) AND 3') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - value', () { engine .analyze('SELECT CASE 1 WHEN 1 THEN (1, 2, 3) ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - when', () { engine .analyze('SELECT CASE 1 WHEN (1, 2, 3) THEN 1 ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); test('in CASE - base', () { engine .analyze('SELECT CASE (1, 2, 3) WHEN 1 THEN 1 ELSE 1 END') .expectError('(1, 2, 3)', type: AnalysisErrorType.rowValueMisuse); }); group('does not generate error for valid usage', () { test('in comparison', () { engine.analyze('SELECT (1, 2, 3) < (?, ?, ?);').expectNoError(); }); test('in IN expression (lhs)', () { engine.analyze('SELECT (1, 2, 3) IN (VALUES(0, 1, 2))').expectNoError(); }); test('in IN expression (rhs)', () { engine.analyze('SELECT ? IN (1, 2, 3)').expectNoError(); }); test('in BETWEEN expression', () { engine.analyze('SELECT (1, 2) BETWEEN (3, 4) AND (5, 6)').expectNoError(); }); test('in CASE expression', () { engine .analyze('SELECT CASE (1, 2) WHEN (1, 2) THEN 1 ELSE 0 END') .expectNoError(); }); }); } test/analysis/errors/returning_test.dart 644 0 0 4072 14047764625 16752 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { final engine = SqlEngine(EngineOptions( enabledExtensions: const [Fts5Extension()], version: SqliteVersion.v3_35, )) ..registerTableFromSql('CREATE TABLE t (id INTEGER PRIMARY KEY, c2 TEXT);') ..registerTableFromSql( 'CREATE VIRTUAL TABLE vt USING fts5 (foo, bar, baz);'); test('does not allow RETURNING for statements in triggers', () { final result = engine.analyze(''' CREATE TRIGGER my_trigger AFTER INSERT ON t BEGIN INSERT INTO t VALUES (1, '') RETURNING *; END; '''); expect(result.errors, hasLength(1)); expect(result.errors.single.type, AnalysisErrorType.illegalUseOfReturning); }); test('does not allow RETURNING on virtual tables', () { final result = engine.analyze("INSERT INTO vt VALUES ('', '', '') RETURNING *;"); expect(result.errors, hasLength(1)); expect(result.errors.single.type, AnalysisErrorType.illegalUseOfReturning); }); test('does not allow star columns with an associated table', () { final result = engine.analyze(''' UPDATE t SET id = t.id + 1 FROM (SELECT * FROM t) AS old RETURNING old.*; '''); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.source!.span!.text, 'source.span.text', 'old.*') .having((e) => e.message, 'message', contains('RETURNING may not use the TABLE.* syntax')), ); }); test('does not allow aggregate expressions', () { final result = engine.analyze('INSERT INTO t DEFAULT VALUES RETURNING ' 'MAX(id) OVER (PARTITION BY c2)'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.source!.span!.text, 'source.span.text', 'MAX(id) OVER (PARTITION BY c2)') .having((e) => e.message, 'message', 'Aggregate expressions are not allowed in RETURNING'), ); }); } test/analysis/errors/view_column_names_mismatch_test.dart 644 0 0 765 13676163307 22316 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('reports column name mismatches in CREATE VIEW statements', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('CREATE VIEW my_view (foo) AS ' 'SELECT * FROM demo;'); expect(result.errors, hasLength(1)); final error = result.errors.single; expect(error.type, AnalysisErrorType.viewColumnNamesMismatch); }); } test/analysis/errors/raise_outside_of_triggers_test.dart 644 0 0 1563 14047764625 22170 0ustar0 pubpubimport 'package:sqlparser/src/analysis/analysis.dart'; import 'package:sqlparser/src/engine/sql_engine.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('does not report errors for RAISE used in triggers', () { final engine = SqlEngine(); engine.registerTable(demoTable); final result = engine.analyze(''' CREATE TRIGGER my_trigger AFTER INSERT ON demo BEGIN SELECT RAISE(FAIL, 'Not allowed'); END; '''); expect(result.errors, isEmpty); }); test('does not allow RAISE in top-level statements', () { final engine = SqlEngine(); final result = engine.analyze("SELECT RAISE(FAIL, 'Not allowed');"); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.type, 'type', AnalysisErrorType.raiseMisuse), ); }); } test/analysis/errors/create_table_errors_test.dart 644 0 0 5072 14213402317 20722 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { final oldEngine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)); final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); final engineInDriftMode = SqlEngine( EngineOptions(version: SqliteVersion.v3_37, useDriftExtensions: true)); group('using STRICT', () { test('with an old sqlite3 version', () { const stmt = 'CREATE TABLE a (c INTEGER) STRICT'; oldEngine.analyze(stmt).expectError('STRICT', type: AnalysisErrorType.notSupportedInDesiredVersion); engine.analyze(stmt).expectNoError(); }); test( 'without a column type', () { engine .analyze('CREATE TABLE a (c) STRICT;') .expectError('c', type: AnalysisErrorType.noTypeNameInStrictTable); }, ); test( 'with an invalid column type', () { engine.analyze('CREATE TABLE a (c INTEGER(12)) STRICT;').expectError( 'INTEGER(12)', type: AnalysisErrorType.invalidTypeNameInStrictTable, ); }, ); test('with a type that is only valid in drift mode', () { // https://github.com/simolus3/drift/discussions/1651 engineInDriftMode .analyze('CREATE TABLE a (c IS_DATETIME, b DECIMAL, c REAL) STRICT;') .expectNoError(); }); }); test('using WITHOUT ROWID and then not declaring a primary key', () { engine .analyze('CREATE TABLE a (c INTEGER) WITHOUT ROWID') .expectError('a', type: AnalysisErrorType.missingPrimaryKey); engine.analyze('CREATE TABLE a (c INTEGER);').expectNoError(); engine .analyze('CREATE TABLE a (c INTEGER PRIMARY KEY) WITHOUT ROWID;') .expectNoError(); final errors = engine.analyze('CREATE TABLE a (c INTEGER, PRIMARY KEY (c));'); expect( errors, isNot(contains( analysisErrorWith(type: AnalysisErrorType.missingPrimaryKey)))); }); test('multiple primary key constraints', () { engine .analyze( 'CREATE TABLE a (c INTEGER PRIMARY KEY, c2 INTEGER PRIMARY KEY)') .expectError('PRIMARY KEY', type: AnalysisErrorType.duplicatePrimaryKeyDeclaration); final errors = engine .analyze('CREATE TABLE a (c INTEGER PRIMARY KEY, c2, PRIMARY KEY (c2))') .errors; expect( errors, contains(analysisErrorWith( lexeme: 'PRIMARY KEY (c2)', type: AnalysisErrorType.duplicatePrimaryKeyDeclaration)), ); }); } test/analysis/errors/values_select_count_mismatch_test.dart 644 0 0 1175 14000111271 22635 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('reports error when using different-length tuples in VALUES', () { final stmt = SqlEngine().analyze('VALUES (1, 2), (3)'); expect( stmt.errors, contains( isA() .having((e) => e.type, 'type', AnalysisErrorType.valuesSelectCountMismatch) .having((e) => e.message, 'message', allOf(contains('1'), contains('2'))) .having((e) => e.relevantNode!.span!.text, 'relevantNode.span.text', '(3)'), ), ); }); } test/analysis/types2/graph_test.dart 644 0 0 1035 14000111271 15710 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:test/test.dart'; class _FakeTypeable implements Typeable {} void main() { test('copies types for a CopyTypeFrom relation', () { final first = _FakeTypeable(); final second = _FakeTypeable(); final graph = TypeGraph(); graph[first] = const ResolvedType.bool(); graph.addRelation(CopyTypeFrom(second, first)); graph.performResolve(); expect(graph[second], const ResolvedType.bool()); }); } test/analysis/types2/resolver_test.dart 644 0 0 25037 14206505103 16511 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/analysis/types/types.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTable(demoTable) ..registerTable(anotherTable); TypeResolver _obtainResolver(String sql, {AnalyzeStatementOptions? options}) { final context = engine.analyze(sql, stmtOptions: options); return TypeResolver(TypeInferenceSession(context))..run(context.root); } ResolvedType? _resolveFirstVariable(String sql, {AnalyzeStatementOptions? options}) { final resolver = _obtainResolver(sql, options: options); final session = resolver.session; final variable = session.context.root.allDescendants.whereType().first; return session.typeOf(variable); } ResolvedType? _resolveResultColumn(String sql) { final resolver = _obtainResolver(sql); final session = resolver.session; final stmt = session.context.root as SelectStatement; return session.typeOf(stmt.resolvedColumns!.single); } test('resolves literals', () { expect(_resolveResultColumn('SELECT NULL'), const ResolvedType(type: BasicType.nullType, nullable: true)); expect(_resolveResultColumn('SELECT TRUE'), const ResolvedType.bool()); expect(_resolveResultColumn("SELECT x''"), const ResolvedType(type: BasicType.blob)); expect(_resolveResultColumn("SELECT ''"), const ResolvedType(type: BasicType.text)); expect(_resolveResultColumn('SELECT 3'), const ResolvedType(type: BasicType.int)); expect(_resolveResultColumn('SELECT 3.5'), const ResolvedType(type: BasicType.real)); }); test('infers boolean type in where conditions', () { expect(_resolveFirstVariable('SELECT * FROM demo WHERE :foo'), const ResolvedType.bool()); }); test('does not infer boolean for grandchildren of where clause', () { expect(_resolveFirstVariable("SELECT * FROM demo WHERE 'foo' = :foo"), const ResolvedType(type: BasicType.text)); }); test('infers boolean type in a join ON clause', () { expect( _resolveFirstVariable('SELECT * FROM demo JOIN tbl ON :foo'), const ResolvedType.bool(), ); }); test('infers type in a string concatenation', () { expect(_resolveFirstVariable("SELECT '' || :foo"), const ResolvedType(type: BasicType.text)); }); test('resolves arithmetic expressions', () { expect(_resolveFirstVariable('SELECT ((3 + 4) * 5) = ?'), const ResolvedType(type: BasicType.int)); }); group('cast expressions', () { test('resolve to type argument', () { expect(_resolveResultColumn('SELECT CAST(3+4 AS TEXT)'), const ResolvedType(type: BasicType.text)); }); test('allow anything as their operand', () { expect(_resolveFirstVariable('SELECT CAST(? AS TEXT)'), null); }); }); group('types in insert statements', () { test('for VALUES', () { final resolver = _obtainResolver('INSERT INTO demo VALUES (:id, :content);'); final root = resolver.session.context.root; final variables = root.allDescendants.whereType(); final idVar = variables.singleWhere((v) => v.resolvedIndex == 1); final contentVar = variables.singleWhere((v) => v.resolvedIndex == 2); expect(resolver.session.typeOf(idVar), id.type); expect(resolver.session.typeOf(contentVar), content.type); }); test('for SELECT', () { final resolver = _obtainResolver('INSERT INTO demo SELECT :id, :content'); final root = resolver.session.context.root; final variables = root.allDescendants.whereType(); final idVar = variables.singleWhere((v) => v.resolvedIndex == 1); final contentVar = variables.singleWhere((v) => v.resolvedIndex == 2); expect(resolver.session.typeOf(idVar), id.type); expect(resolver.session.typeOf(contentVar), content.type); }); }); test('recognizes that variables are the same', () { // semantically, :var and ?1 are the same variable final type = _resolveFirstVariable('SELECT :var WHERE ?1'); expect(type, const ResolvedType.bool()); }); test('respects variable types set from options', () { const type = ResolvedType(type: BasicType.text); // should resolve to string, even though it would be a boolean normally final found = _resolveFirstVariable( 'SELECT * FROM demo WHERE ?', options: const AnalyzeStatementOptions(indexedVariableTypes: {1: type}), ); expect(found, type); }); test('handles LIMIT clauses', () { const int = ResolvedType(type: BasicType.int); final type = _resolveFirstVariable('SELECT 0 LIMIT ?'); expect(type, int); final offsetType = _resolveFirstVariable('SELECT 0 LIMIT 1, ?'); expect(offsetType, int); }); test('handles string matching expressions', () { final type = _resolveFirstVariable('SELECT * FROM demo WHERE content LIKE ?'); expect(type, const ResolvedType(type: BasicType.text)); final escapedType = _resolveFirstVariable( "SELECT * FROM demo WHERE content LIKE 'foo' ESCAPE ?"); expect(escapedType, const ResolvedType(type: BasicType.text)); }); test('handles nth_value', () { final resolver = _obtainResolver("SELECT nth_value('string', ?1) = ?2"); final variables = resolver.session.context.root.allDescendants .whereType() .iterator; variables.moveNext(); final firstVar = variables.current; variables.moveNext(); final secondVar = variables.current; expect(resolver.session.typeOf(firstVar), equals(const ResolvedType(type: BasicType.int))); expect(resolver.session.typeOf(secondVar), equals(const ResolvedType(type: BasicType.text))); }); group('case expressions', () { test('infers base clause from when', () { final type = _resolveFirstVariable("SELECT CASE ? WHEN 1 THEN 'two' END"); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers when condition from base', () { final type = _resolveFirstVariable("SELECT CASE 1 WHEN ? THEN 'two' END"); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers when conditions as boolean when no base is set', () { final type = _resolveFirstVariable("SELECT CASE WHEN ? THEN 'two' END;"); expect(type, const ResolvedType.bool()); }); test('infers type of whole when expression', () { final type = _resolveResultColumn("SELECT CASE WHEN false THEN 'one' " "WHEN true THEN 'two' ELSE 'three' END;"); expect(type, const ResolvedType(type: BasicType.text)); }); }); test('can select columns', () { final type = _resolveResultColumn('SELECT id FROM demo;'); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers type of EXISTS expressions', () { final type = _resolveResultColumn('SELECT EXISTS(SELECT * FROM demo);'); expect(type, const ResolvedType.bool()); }); test('resolves subqueries', () { final type = _resolveResultColumn('SELECT (SELECT COUNT(*) FROM demo);'); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers types for dart placeholders', () { final resolver = _obtainResolver(r'SELECT * FROM demo WHERE $pred'); final type = resolver.session.typeOf(resolver .session.context.root.allDescendants .firstWhere((e) => e is DartExpressionPlaceholder) as DartExpressionPlaceholder); expect(type, const ResolvedType.bool()); }); test('supports unions', () { void check(String sql) { final resolver = _obtainResolver(sql); final column = (resolver.session.context.root as CompoundSelectStatement) .resolvedColumns! .single; final type = resolver.session.typeOf(column)!; expect(type.type, BasicType.text); expect(type.nullable, isTrue); } check("SELECT 'foo' AS r UNION ALL SELECT NULL AS r"); check("SELECT NULL AS r UNION ALL SELECT 'foo' AS r"); }); test('handles recursive CTEs', () { final type = _resolveResultColumn(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt '''); expect(type, const ResolvedType(type: BasicType.int)); }); test('handles set components in updates', () { final type = _resolveFirstVariable('UPDATE demo SET id = ?'); expect(type, const ResolvedType(type: BasicType.int)); }); test('infers offsets in frame specs', () { final type = _resolveFirstVariable('SELECT SUM(id) OVER (ROWS ? PRECEDING)'); expect(type, const ResolvedType(type: BasicType.int)); }); test('resolves type hints from between expressions', () { const dateTime = ResolvedType(type: BasicType.int, hint: IsDateTime()); final session = _obtainResolver( 'SELECT 1 WHERE :date BETWEEN :start AND :end', options: const AnalyzeStatementOptions( namedVariableTypes: {':date': dateTime}, ), ).session; Variable? start, end; for (final variable in session.context.root.allDescendants .whereType()) { if (variable.name == ':start') start = variable; if (variable.name == ':end') end = variable; } assert(start != null && end != null); expect(session.typeOf(start), dateTime); expect(session.typeOf(end), dateTime); }); group('IS IN expressions', () { test('infer the variable as an array type', () { final type = _resolveFirstVariable('SELECT 3 IN ?'); expect(type, const ResolvedType(type: BasicType.int, isArray: true)); }); test('does not infer the variable as an array when in a tuple', () { final type = _resolveFirstVariable('SELECT 3 IN (?)'); expect(type, const ResolvedType(type: BasicType.int, isArray: false)); }); }); test('columns from LEFT OUTER joins are nullable', () { final resolver = _obtainResolver(''' WITH sq_1 (one ) AS (SELECT 1), sq_2 (two) AS (SELECT 2), sq_3 (three) AS (SELECT 3) SELECT one, two, three FROM sq_1 LEFT JOIN sq_2 LEFT OUTER JOIN sq_3 '''); final session = resolver.session; final stmt = resolver.session.context.root as SelectStatement; final columns = stmt.resolvedColumns!; expect(session.typeOf(columns[0]), const ResolvedType(type: BasicType.int)); expect(session.typeOf(columns[1]), const ResolvedType(type: BasicType.int, nullable: true)); expect(session.typeOf(columns[2]), const ResolvedType(type: BasicType.int, nullable: true)); }); } test/analysis/types2/join_analysis_test.dart 644 0 0 1721 14071371536 17477 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; void main() { test('correctly reports results for aliases', () { final engine = SqlEngine()..registerTable(demoTable); final stmt = engine.analyze(''' SELECT a1.*, a2.* FROM demo AS a1 LEFT JOIN demo AS a2 ON FALSE INNER JOIN demo AS a3 ON TRUE; ''').root; final model = JoinModel.of(stmt)!; expect( model.isNullableTable(stmt.scope .resolve('a1')! .resultSet .resultSet!), isFalse, ); expect( model.isNullableTable(stmt.scope .resolve('a2')! .resultSet .resultSet!), isTrue, ); expect( model.isNullableTable(stmt.scope .resolve('a3')! .resultSet .resultSet!), isFalse, ); }); } test/analysis/types2/misc_cases_test.dart 644 0 0 10551 14213402317 16755 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../data.dart'; // Cases copied from the regular type inference algorithm test const Map _types = { 'SELECT * FROM demo WHERE id = ?': ResolvedType(type: BasicType.int), 'SELECT * FROM demo WHERE content = ?': ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content == ?': ResolvedType(type: BasicType.text), 'SELECT * FROM demo LIMIT ?': ResolvedType(type: BasicType.int), 'SELECT 1 FROM demo GROUP BY id HAVING COUNT(*) = ?': ResolvedType(type: BasicType.int), 'SELECT 1 FROM demo WHERE id BETWEEN 3 AND ?': ResolvedType(type: BasicType.int), 'UPDATE demo SET content = ? WHERE id = 3': ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content LIKE ?': ResolvedType(type: BasicType.text), "SELECT * FROM demo WHERE content LIKE '%e' ESCAPE ?": ResolvedType(type: BasicType.text), 'SELECT * FROM demo WHERE content IN ?': ResolvedType(type: BasicType.text, isArray: true), 'SELECT * FROM demo WHERE content IN (?)': ResolvedType(type: BasicType.text, isArray: false), 'SELECT * FROM demo JOIN tbl ON demo.id = tbl.id WHERE date = ?': ResolvedType(type: BasicType.int, hint: IsDateTime()), 'SELECT row_number() OVER (RANGE ? PRECEDING)': ResolvedType(type: BasicType.int), 'SELECT ?;': null, 'SELECT CAST(3 AS TEXT) = ?': ResolvedType(type: BasicType.text), 'SELECT (3 * 4) = ?': ResolvedType(type: BasicType.int), 'SELECT (3 / 4) = ?': ResolvedType(type: BasicType.int), 'SELECT (3 / 4.) = ?': ResolvedType(type: BasicType.real), 'SELECT NULLIF(3, 3) IS ?': ResolvedType(type: BasicType.int, nullable: true), 'SELECT CURRENT_TIMESTAMP = ?': ResolvedType(type: BasicType.text), "SELECT COALESCE(NULL, 'foo') = ?": ResolvedType(type: BasicType.text), 'SELECT NULLIF(3, 4) = ?': ResolvedType(type: BasicType.int, nullable: true), "SELECT 'foo' COLLATE NOCASE = ?": ResolvedType(type: BasicType.text), 'SELECT ? COLLATE BINARY': ResolvedType(type: BasicType.text), "SELECT ('foo' + 'bar') = ?": ResolvedType(type: BasicType.int), 'INSERT INTO demo DEFAULT VALUES ON CONFLICT (id) WHERE ? DO NOTHING': ResolvedType.bool(), 'INSERT INTO demo DEFAULT VALUES ON CONFLICT DO UPDATE SET id = id WHERE ?': ResolvedType.bool(), 'SELECT GROUP_CONCAT(content) = ? FROM demo;': ResolvedType(type: BasicType.text, nullable: true), "SELECT '' -> '' = ?": ResolvedType(type: BasicType.text, nullable: true), "SELECT '' ->> '' = ?": null, "SELECT ? -> 'a' = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT ? ->> 'a' = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT 'a' -> ? = 'b'": ResolvedType(type: BasicType.text, nullable: false), "SELECT 'a' ->> ? = 'b'": ResolvedType(type: BasicType.text, nullable: false), }; SqlEngine _spawnEngine() { return SqlEngine() ..registerTable(demoTable) ..registerTable(anotherTable); } void main() { group('miscellaneous type inference cases', () { _types.forEach((sql, expected) { test('for $sql', () { final engine = _spawnEngine(); final content = engine.analyze(sql); final variable = content.root.allDescendants .firstWhere((node) => node is Variable) as Typeable; expect(content.typeOf(variable).type, equals(expected)); }); }); }); test('resolves all expressions in CTE', () { final engine = _spawnEngine(); final content = engine.analyze(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; '''); final expressions = content.root.allDescendants.whereType(); expect( expressions.map((e) => content.typeOf(e).type), everyElement(isNotNull), ); }); test('concatenation is nullable when any part is', () { // https://github.com/simolus3/drift/issues/1719 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE foobar (foo TEXT, bar TEXT);'); final content = engine.analyze("SELECT foo, bar, foo || ' ' || bar FROM foobar;"); final columns = (content.root as SelectStatement).resolvedColumns!; expect( columns.map(content.typeOf), everyElement(isA() .having((e) => e.type?.nullable, 'type.nullable', isTrue))); }); } test/analysis/available_tables_test.dart 644 0 0 3166 14206505103 16653 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('allows unqualified references to aliased table', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo d WHERE id'); expect(result.errors, isEmpty); }); test('does not allow references with wrong alias', () { final engine = SqlEngine()..registerTable(demoTable); final result = engine.analyze('SELECT * FROM demo d WHERE demo.id = 0'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.span?.text, 'span.text', 'demo.id') .having( (e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable), ); }); test('does not register the same result set multiple times', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTableFromSql(''' CREATE TABLE with_defaults ( a TEXT DEFAULT 'something', b INT UNIQUE ); ''') ..registerTableFromSql(''' CREATE TABLE with_constraints ( a TEXT, b INT NOT NULL, c FLOAT(10, 2), FOREIGN KEY (a, b) REFERENCES with_defaults (a, b) ); '''); final result = engine.analyze(r''' SELECT d.*, c.** FROM with_defaults d LEFT OUTER JOIN with_constraints c ON d.a = c.a AND d.b = c.b WHERE $predicate; '''); final scope = result.root.scope; expect(scope.allOf(), hasLength(2)); }); } test/analysis/schema/table_test.dart 644 0 0 2156 14000111271 15715 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { group('finds columns', () { final engine = SqlEngine(); const schemaParser = SchemaFromCreateTable(); Column? findWith(String createTbl, String columnName) { final stmt = engine.parse(createTbl).rootNode as CreateTableStatement; final table = schemaParser.read(stmt); return table.findColumn(columnName); } test('when declared in table', () { expect(findWith('CREATE TABLE x (__rowid__ VARCHAR)', '__rowid__'), isA()); }); test('when alias to rowid', () { final column = findWith('CREATE TABLE x (id INTEGER PRIMARY KEY)', 'oid'); expect(column?.name, 'id'); expect(column, isA()); }); test('when virtual rowid column', () { final column = findWith('CREATE TABLE x (id VARCHAR)', 'oid'); expect(column, isA()); }); test('when not found', () { final column = findWith( 'CREATE TABLE x (id INTEGER PRIMARY KEY) WITHOUT ROWID', 'oid'); expect(column, isNull); }); }); } test/analysis/schema/from_create_table_test.dart 644 0 0 15770 14206506613 20331 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../../common_data.dart'; import '../data.dart'; const _affinityTests = { 'INT': BasicType.int, 'INTEGER': BasicType.int, 'TINYINT': BasicType.int, 'SMALLINT': BasicType.int, 'MEDIUMINT': BasicType.int, 'BIGINT': BasicType.int, 'UNISGNED BIG INT': BasicType.int, 'INT2': BasicType.int, 'INT8': BasicType.int, 'CHARACTER(20)': BasicType.text, 'CHARACTER(255)': BasicType.text, 'VARYING CHARACTER(255)': BasicType.text, 'NCHAR(55)': BasicType.text, 'NATIVE CHARACTER(70)': BasicType.text, 'NVARCHAR(100)': BasicType.text, 'TEXT': BasicType.text, 'CLOB': BasicType.text, 'BLOB': BasicType.blob, null: BasicType.blob, 'REAL': BasicType.real, 'DOUBLE': BasicType.real, 'DOUBLE PRECISION': BasicType.real, 'FLOAT': BasicType.real, 'NUMERIC': BasicType.real, 'DECIMAL(10,5)': BasicType.real, 'BOOLEAN': BasicType.real, 'DATE': BasicType.real, 'DATETIME': BasicType.real, }; void main() { test('affinity from typename', () { const resolver = SchemaFromCreateTable(); _affinityTests.forEach((key, value) { expect(resolver.columnAffinity(key), equals(value), reason: '$key should have $value affinity'); }); }); test('export table structure', () { final engine = SqlEngine(); final stmt = engine.parse(createTableStmt).rootNode; final table = const SchemaFromCreateTable().read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.name), ['id', 'email', 'score', 'display_name']); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int), ResolvedType(type: BasicType.text), ResolvedType(type: BasicType.int), ResolvedType(type: BasicType.text, nullable: true), ]); expect(table.tableConstraints, hasLength(2)); }); test('reads isGenerated', () { final engine = SqlEngine(); final stmt = engine.parse(''' CREATE TABLE tbl ( a TEXT, b TEXT GENERATED ALWAYS AS (UPPER(b)) ); ''').rootNode; final table = const SchemaFromCreateTable().read(stmt as CreateTableStatement); expect( table.findColumn('a'), isA().having((e) => e.isGenerated, 'isGenerated', isFalse), ); expect( table.findColumn('b'), isA().having((e) => e.isGenerated, 'isGenerated', isTrue), ); }); test('supports booleans when drift extensions are enabled', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)); final stmt = engine.parse(''' CREATE TABLE foo ( a BOOL, b DATETIME, c DATE, d BOOLEAN NOT NULL ) ''').rootNode; final table = const SchemaFromCreateTable(driftExtensions: true) .read(stmt as CreateTableStatement); expect(table.resolvedColumns.map((c) => c.type), const [ ResolvedType(type: BasicType.int, hint: IsBoolean(), nullable: true), ResolvedType(type: BasicType.int, hint: IsDateTime(), nullable: true), ResolvedType(type: BasicType.int, hint: IsDateTime(), nullable: true), ResolvedType(type: BasicType.int, hint: IsBoolean(), nullable: false), ]); }); group('can read views', () { View readView(String sql) { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(sql); expect(context.errors, isEmpty); final stmt = context.root as CreateViewStatement; return const SchemaFromCreateTable().readView(context, stmt); } test('without column names', () { final view = readView('CREATE VIEW my_view AS SELECT * FROM demo;'); expect(view.name, 'my_view'); expect(view.resolvedColumns.map((e) => e.name), ['id', 'content']); expect( view.resolvedColumns.map((e) => e.type!.type), [BasicType.int, BasicType.text], ); }); test('with custom column names', () { final view = readView( 'CREATE VIEW another_view (foo, bar) AS SELECT * FROM demo;'); expect(view.name, 'another_view'); expect(view.resolvedColumns.map((e) => e.name), ['foo', 'bar']); }); test('with WITH clause', () { final view = readView('CREATE VIEW my_view AS ' 'WITH foo AS (SELECT * FROM demo) SELECT * FROM foo;'); expect(view.name, 'my_view'); expect(view.resolvedColumns.map((e) => e.name), ['id', 'content']); }); }); test('can read columns without type name', () { final engine = SqlEngine(); final stmt = engine.parse('CREATE TABLE foo (id);').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.type, BasicType.blob); }); test('aliases to rowid are non-nullable', () { final engine = SqlEngine(); final stmt = engine.parse('CREATE TABLE foo (id INTEGER PRIMARY KEY);').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type, const ResolvedType(type: BasicType.int, nullable: false)); }); group('the primary key of a STRICT table is non-nullable', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); test('when declared on the column', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT PRIMARY KEY) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); test('when declared on the table', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT, PRIMARY KEY (bar)) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); test('even when it has a NULL constraint', () { final stmt = engine .parse('CREATE TABLE foo (bar TEXT NULL, PRIMARY KEY (bar)) STRICT;') .rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.resolvedColumns.single.type.nullable, isFalse); }); }); group('sets withoutRowid and isStrict', () { final engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_37)); void testWith(String suffix, bool withoutRowid, bool strict) { final stmt = engine.parse('CREATE TABLE foo (bar TEXT) $suffix;').rootNode; final table = engine.schemaReader.read(stmt as CreateTableStatement); expect(table.withoutRowId, withoutRowid); expect(table.isStrict, strict); } test('when the table is neither', () { testWith('', false, false); }); test('when the table is without rowid', () { testWith('WITHOUT ROWID', true, false); }); test('when the table is strict', () { testWith('STRICT', false, true); }); test('when the table is both', () { testWith('WITHOUT ROWID, STRICT', true, true); testWith('STRICT, WITHOUT ROWID', true, true); }); }); } test/analysis/schema/column_test.dart 644 0 0 1676 13764474313 16162 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('isAliasForRowId', () { final engine = SqlEngine(); const schemaParser = SchemaFromCreateTable(); final isAlias = { 'CREATE TABLE x (id INTEGER PRIMARY KEY)': true, 'CREATE TABLE x (id INTEGER PRIMARY KEY) WITHOUT ROWID': false, 'CREATE TABLE x (id BIGINT PRIMARY KEY)': false, 'CREATE TABLE x (id INTEGER PRIMARY KEY DESC)': false, 'CREATE TABLE x (id INTEGER)': false, 'CREATE TABLE x (id INTEGER, PRIMARY KEY (id))': true, }; isAlias.forEach((createTblString, isAlias) { final parsed = engine.parse(createTblString).rootNode as CreateTableStatement; final table = schemaParser.read(parsed); expect( (table.findColumn('id') as TableColumn).isAliasForRowId(), isAlias, reason: '$createTblString: id is an alias? $isAlias', ); }); }); } test/analysis/regression_test.dart 644 0 0 11375 14213402317 15603 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('regression test for #917', () { // Test for https://github.com/simolus3/drift/issues/917 final engine = SqlEngine() ..registerTableFromSql('CREATE TABLE Shops (id INTEGER);') ..registerTableFromSql( 'CREATE TABLE Sales (shop_id INTEGER, date INTEGER, amount REAL);'); final result = engine.analyze(''' SELECT Shops.id, SalesYesterday.amount AS amount_yesterday, SalesToday.amount AS amount_today FROM Sales AS SalesYesterday, ( SELECT SalesToday.amount AS amount, SalesToday.shop_id AS shop_id FROM Sales AS SalesToday LEFT JOIN Shops ON SalesToday.shop_id = Shops.id WHERE SalesToday.date = 8 ) AS SalesToday INNER JOIN Shops ON (SalesYesterday.shop_id = Shops.id) AND (SalesToday.shop_id = Shops.id) WHERE SalesYesterday.date = 9 ORDER BY Shops.id; '''); expect(result.errors, isEmpty); }); test('regression test for #1188', () { // Test for https://github.com/simolus3/drift/issues/1188 final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTableFromSql(''' CREATE TABLE IF NOT EXISTS "employees" ( "id" INTEGER NOT NULL PRIMARY KEY, "name" TEXT NOT NULL UNIQUE, "manager_id" INTEGER ); ''') ..registerTableFromSql(''' CREATE TABLE IF NOT EXISTS "employee_notes" ( "employee_id" INTEGER NOT NULL PRIMARY KEY, "note" TEXT ); '''); final result = engine.analyze(''' WITH RECURSIVE employeeHierarchy(id, name, manager_id) AS ( SELECT id, name, manager_id FROM employees WHERE manager_id IS NULL UNION ALL SELECT e.id, e.name, e.manager_id FROM employees e JOIN employeeHierarchy ON e.manager_id = employeeHierarchy.id ) SELECT e.id, e.name, e.manager_id, n.note FROM employeeHierarchy e LEFT OUTER JOIN employee_notes n ON e.id = n.employee_id ORDER BY e.id; '''); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; expect(columns.map((e) => e.name), ['id', 'name', 'manager_id', 'note']); expect(columns.map((e) => result.typeOf(e).nullable), [false, false, true, true]); }); test('regression test for #1234', () { // https://github.com/simolus3/drift/issues/1234#issuecomment-853270925 final engine = SqlEngine(EngineOptions(useDriftExtensions: true)) ..registerTableFromSql(''' CREATE TABLE inboxes ( id TEXT PRIMARY KEY NOT NULL, group_id TEXT NOT NULL ); ''') ..registerTableFromSql(''' CREATE TABLE assignable_users ( user_id TEXT NOT NULL, inbox_id TEXT NOT NULL ); '''); final result = engine.analyze(''' SELECT * FROM inboxes as i LEFT JOIN assignable_users as au ON au.inbox_id = i.id WHERE group_id = :group_id; '''); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; expect( columns.map((e) => e.name), ['id', 'group_id', 'user_id', 'inbox_id']); expect(columns.map((e) => result.typeOf(e).nullable), [false, false, true, true]); }); test('regression test for #1096', () { // https://github.com/simolus3/drift/issues/1096#issuecomment-931378474 final engine = SqlEngine( EngineOptions(useDriftExtensions: true, version: SqliteVersion.v3_35)) ..registerTableFromSql(''' CREATE TABLE downloads ( id INT NOT NULL PRIMARY KEY AUTOINCREMENT, uri TEXT NOT NULL, last_modified_time INT, attempts_started_count INT NOT NULL DEFAULT 0, priority INT NOT NULL DEFAULT 0, last_attempt_timestamp INT, status TEXT NOT NULL, handed_off bool NOT NULL DEFAULT false, sync_session INT NOT NULL, UNIQUE (sync_session, uri) ); '''); final result = engine.analyze(''' UPDATE downloads SET status = 'CHECKED_OUT' FROM ( SELECT * FROM downloads ) as w WHERE downloads.id = w.id RETURNING downloads.id; '''); expect(result.errors, isEmpty); final select = result.root as UpdateStatement; final columns = select.returnedResultSet!.resolvedColumns!; expect(columns, hasLength(1)); expect( result.typeOf(columns.single).type, isA() .having((e) => e.type, 'type', BasicType.int) .having((e) => e.nullable, 'nullable', isFalse)); }); } test/analysis/common_table_expressions.dart 644 0 0 3174 14000111271 17431 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('resolves columns from CTEs', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' WITH cte (foo, bar) AS (SELECT * FROM demo) SELECT * FROM cte; '''); expect(context.errors, isEmpty); final select = context.root as SelectStatement; expect(select.resolvedColumns!.map((c) => c.name), ['foo', 'bar']); expect( select.resolvedColumns!.map((c) => context.typeOf(c).type), [id.type, content.type], ); }); test('warns on column count mismatch', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze(''' WITH cte (foo, bar, baz) AS (SELECT * FROM demo) SELECT 1; '''); expect(context.errors, hasLength(1)); final error = context.errors.single; expect(error.type, AnalysisErrorType.cteColumnCountMismatch); expect(error.message, stringContainsInOrder(['3', '2'])); }); test('handles recursive CTEs', () { final engine = SqlEngine(); final context = engine.analyze(''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; '''); expect(context.errors, isEmpty); final select = context.root as SelectStatement; final column = select.resolvedColumns!.single; final type = context.typeOf(column); expect(type.type, const ResolvedType(type: BasicType.int)); expect(column.name, 'x'); }); } test/analysis/variable_indexing_test.dart 644 0 0 1470 14131303604 17046 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { test('resolves index of variables', () { final engine = SqlEngine()..registerTable(demoTable); final context = engine.analyze('SELECT ? = :test FROM demo LIMIT ?4 OFFSET ?;'); // indices: 1 2 4 5 final select = context.root as SelectStatement; final firstEquals = (select.columns[0] as ExpressionResultColumn).expression as BinaryExpression; final limit = select.limit as Limit; expect((firstEquals.left as Variable).resolvedIndex, 1); expect((firstEquals.right as Variable).resolvedIndex, 2); expect((limit.count as Variable).resolvedIndex, 4); expect((limit.offset as Variable).resolvedIndex, 5); }); } test/analysis/column_resolver_test.dart 644 0 0 15435 14155120333 16642 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'data.dart'; void main() { late SqlEngine engine; setUp(() { engine = SqlEngine(EngineOptions(version: SqliteVersion.v3_35)); engine.registerTable(demoTable); }); group('CREATE TRIGGER statements', () { group('delete', () { test('can use OLD references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON demo BEGIN SELECT * FROM old; END; '''); expect(context.errors, isEmpty); }); test("can't use NEW references", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON demo BEGIN SELECT * FROM new; END; '''); expect( context.errors, contains(const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span!.text, 'span.text', 'new')), ); }); }); group('insert', () { test('can use NEW references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE INSERT ON demo BEGIN SELECT * FROM new; END; '''); expect(context.errors, isEmpty); }); test("can't use OLD references", () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE INSERT ON demo BEGIN SELECT * FROM old; END; '''); expect( context.errors, contains(const TypeMatcher() .having((e) => e.type, 'type', AnalysisErrorType.referencedUnknownTable) .having((e) => e.span!.text, 'span.text', 'old')), ); }); }); test('update can use NEW and OLD references', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE UPDATE ON demo BEGIN SELECT * FROM new; INSERT INTO old VALUES (1, 'foo'); END; '''); expect(context.errors, isEmpty); }); test('can refer to column in UPDATE OF', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE UPDATE OF content ON DEMO BEGIN SELECT * FROM demo; END; '''); expect(context.errors, isEmpty); }); test('can refer to column in UPDATE OF', () { final context = engine.analyze(''' CREATE TRIGGER my_trigger BEFORE DELETE ON DEMO WHEN id < 10 BEGIN SELECT * FROM demo; END; '''); expect(context.errors, isEmpty); }); }); test("DO UPDATE action in upsert can refer to 'exluded'", () { final context = engine.analyze(''' INSERT INTO demo VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET content = content || excluded.content; '''); expect(context.errors, isEmpty); }); test('columns from values statement', () { final context = engine.analyze("VALUES ('foo', 3), ('bar', 5)"); expect(context.errors, isEmpty); final columns = (context.root as ResultSet).resolvedColumns!; expect(columns.map((e) => e.name), ['Column1', 'Column2']); expect(columns.map((e) => context.typeOf(e).type?.type), [BasicType.text, BasicType.int]); }); test('columns from nested VALUES', () { final context = engine.analyze('SELECT Column1 FROM (VALUES (3))'); expect(context.errors, isEmpty); }); test('gracefully handles tuples of different lengths in VALUES', () { final context = engine.analyze("VALUES ('foo', 3), ('bar')"); expect(context.errors, isNotEmpty); final columns = (context.root as ResultSet).resolvedColumns!; expect(columns.map((e) => e.name), ['Column1', 'Column2']); expect(columns.map((e) => context.typeOf(e).type?.type), [BasicType.text, BasicType.int]); }); test('handles update statement with from clause', () { // Example from here: https://www.sqlite.org/lang_update.html#upfrom engine ..registerTableFromSql(''' CREATE TABLE inventory ( itemId INTEGER PRIMARY KEY, quantity INTEGER NOT NULL DEFAULT 0, ); ''') ..registerTableFromSql(''' CREATE TABLE sales ( itemId INTEGER NOT NULL, quantity INTEGER NOT NULL, ); '''); final result = engine.analyze(''' UPDATE inventory SET quantity = quantity - daily.amt FROM (SELECT sum(quantity) AS amt, itemId FROM sales GROUP BY 2) AS daily WHERE inventory.itemId = daily.itemId; '''); expect(result.errors, isEmpty); }); group('resolves RETURNING clause', () { test('for simple inserts', () { final result = engine .analyze("INSERT INTO demo (content) VALUES ('hi') RETURNING *;"); final returning = (result.root as InsertStatement).returnedResultSet; expect(returning, isNotNull); expect(returning!.resolvedColumns!.map((e) => e.name), ['id', 'content']); }); test('for custom expressions', () { final result = engine.analyze("INSERT INTO demo (content) VALUES ('hi') " 'RETURNING content || content AS x;'); final returning = (result.root as InsertStatement).returnedResultSet!; expect(returning.resolvedColumns!.map((e) => e.name), ['x']); }); test('star does not include other tables', () { final result = engine.analyze(''' UPDATE demo SET content = '' FROM (SELECT * FROM demo) AS old RETURNING *; '''); final returning = (result.root as UpdateStatement).returnedResultSet!; expect(returning.resolvedColumns!.map((e) => e.name), ['id', 'content']); }); test('can refer to columns from other tables', () { final result = engine.analyze(''' UPDATE demo SET content = '' FROM (SELECT * FROM demo) AS old RETURNING old.id, old.content; '''); expect(result.errors, isEmpty); }); }); test('reports error when using star wihout tables', () { final result = engine.analyze('SELECT 1, 2, *;'); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having( (e) => e.type, 'type', AnalysisErrorType.starColumnWithoutTable) .having((e) => e.source?.span?.text, 'source.span?.text', '*'), ); }); group('resolves target columns of INSERT', () { test('for regular tables', () { final root = engine.analyze('INSERT INTO demo VALUES (?, ?)').root as InsertStatement; expect(root.resolvedTargetColumns, hasLength(2)); }); test('when there are generated columns', () { engine.registerTableFromSql(''' CREATE TABLE x ( a TEXT NOT NULL, b TEXT GENERATED ALWAYS AS (a) ); '''); final root = engine.analyze('INSERT INTO x VALUES (?, ?)').root as InsertStatement; expect(root.resolvedTargetColumns, hasLength(1)); }); }); } test/parser/moor_file_test.dart 644 0 0 14304 14213402317 15042 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; const content = r''' import 'other.dart'; import 'another.drift'; CREATE TABLE tbl ( id INT NOT NULL PRIMARY KEY AUTOINCREMENT, -- this is a single-line comment place VARCHAR REFERENCES other(location) AS "placeRef" ) AS RowName; all: SELECT /* COUNT(*), */ * FROM tbl WHERE $predicate; @special: SELECT * FROM tbl; typeHints(REQUIRED :foo AS TEXT OR NULL, $predicate = TRUE): SELECT :foo WHERE $predicate; nested AS MyResultSet: SELECT foo.** AS fooRename FROM tbl foo; add: INSERT INTO tbl $row RETURNING *; '''; void main() { test('parses drift files', () { testDriftFile( content, DriftFile([ ImportStatement('other.dart'), ImportStatement('another.drift'), CreateTableStatement( tableName: 'tbl', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INT', constraints: [ NotNull(null), PrimaryKeyColumn(null, autoIncrement: true), ], ), ColumnDefinition( columnName: 'place', typeName: 'VARCHAR', constraints: [ ForeignKeyColumnConstraint( null, ForeignKeyClause( foreignTable: TableReference('other'), columnNames: [ Reference(columnName: 'location'), ], ), ), DriftDartName(null, identifier('placeRef')), ], ), ], driftTableName: DriftTableName('RowName', false), ), DeclaredStatement( SimpleName('all'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), where: DartExpressionPlaceholder(name: 'predicate'), ), ), DeclaredStatement( SpecialStatementIdentifier('special'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), DeclaredStatement( SimpleName('typeHints'), SelectStatement( columns: [ ExpressionResultColumn( expression: ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), ), ], where: DartExpressionPlaceholder(name: 'predicate'), ), parameters: [ VariableTypeHint( ColonNamedVariable( ColonVariableToken(fakeSpan(':foo'), ':foo'), ), 'TEXT', orNull: true, isRequired: true, ), DartPlaceholderDefaultValue( 'predicate', BooleanLiteral.withTrue(token(TokenType.$true)), ), ], ), DeclaredStatement( SimpleName('nested'), SelectStatement( columns: [ NestedStarResultColumn( tableName: 'foo', as: 'fooRename', ) ], from: TableReference('tbl', as: 'foo'), ), as: 'MyResultSet', ), DeclaredStatement( SimpleName('add'), InsertStatement( table: TableReference('tbl'), source: DartInsertablePlaceholder(name: 'row'), targetColumns: const [], returning: Returning([ StarResultColumn(), ]), ), ) ]), ); }); test('parses transaction blocks', () { testDriftFile( ''' test: BEGIN UPDATE foo SET bar = baz; DELETE FROM t; END; ''', DriftFile([ DeclaredStatement( SimpleName('test'), TransactionBlock( begin: BeginTransactionStatement(), innerStatements: [ UpdateStatement( table: TableReference('foo'), set: [ SetComponent( column: Reference(columnName: 'bar'), expression: Reference(columnName: 'baz'), ), ], ), DeleteStatement(from: TableReference('t')), ], commit: CommitStatement(), ), ), ]), ); }); test("reports error when the statement can't be parsed", () { // regression test for https://github.com/simolus3/drift/issues/280#issuecomment-570789454 final parsed = SqlEngine(EngineOptions(useDriftExtensions: true)) .parseDriftFile('name: NSERT INTO foo DEFAULT VALUES;'); expect( parsed.errors, contains(const TypeMatcher().having( (e) => e.message, 'message', contains('Expected a sql statement here'), )), ); final root = parsed.rootNode as DriftFile; expect( root.allDescendants, isNot(contains(const TypeMatcher())), ); }); test('syntax errors contain correct position', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)); final result = engine.parseDriftFile(''' worksByComposer: SELECT DISTINCT A.* FROM works A, works B ON A.id = WHERE A.composer = :id OR B.composer = :id; '''); expect(result.errors, hasLength(1)); expect( result.errors.single, isA() .having((e) => e.token.lexeme, 'token.lexeme', 'WHERE')); }); test('parses REQUIRED without type hint', () { final variable = ColonVariableToken(fakeSpan(':category'), ':category'); testDriftFile( 'test(REQUIRED :category): SELECT :category;', DriftFile([ DeclaredStatement( SimpleName('test'), SelectStatement(columns: [ ExpressionResultColumn( expression: ColonNamedVariable(variable), ), ]), parameters: [ VariableTypeHint( ColonNamedVariable(variable), null, isRequired: true, ), ], ), ]), ); }); } test/parser/inline_dart_test.dart 644 0 0 3367 14206506764 15363 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses limit components', () { testStatement( r'SELECT * FROM tbl LIMIT $limit', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), limit: DartLimitPlaceholder(name: 'limit'), ), driftMode: true, ); }); test('parses limit count as expressions', () { testStatement( r'SELECT * FROM tbl LIMIT $amount OFFSET 3', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), limit: Limit( count: DartExpressionPlaceholder(name: 'amount'), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(3, token(TokenType.numberLiteral)), ), ), driftMode: true, ); }); test('parses ordering terms and ordering expressions', () { testStatement( r'SELECT * FROM tbl ORDER BY $term, $expr DESC', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), orderBy: OrderBy( terms: [ DartOrderingTermPlaceholder(name: 'term'), OrderingTerm( expression: DartExpressionPlaceholder(name: 'expr'), orderingMode: OrderingMode.descending, ), ], ), ), driftMode: true, ); }); test('parses full order by placeholders', () { testStatement( r'SELECT * FROM tbl ORDER BY $order', SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), orderBy: DartOrderByPlaceholder(name: 'order'), ), driftMode: true, ); }); } test/parser/create_view_test.dart 644 0 0 7174 14206506746 15370 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses a simple create view statement', () { testStatement( 'CREATE VIEW my_view AS SELECT * FROM my_tbl', CreateViewStatement( viewName: 'my_view', query: SelectStatement( columns: [StarResultColumn()], from: TableReference('my_tbl'), ), ), ); }); test('parses a CREATE VIEW statement with an existing Dart class', () { testStatement( 'CREATE VIEW my_view WITH ExistingDartClass AS SELECT 1', CreateViewStatement( viewName: 'my_view', query: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(1, token(TokenType.numberLiteral)), ), ], ), driftTableName: DriftTableName('ExistingDartClass', true), ), driftMode: true, ); }); test('parses a complex CREATE View statement', () { testStatement( 'CREATE VIEW IF NOT EXISTS my_complex_view (ids, name, count, type) AS ' 'SELECT group_concat(id), name, count(*),\'dog\' FROM dogs GROUP BY name' ' UNION ' 'SELECT group_concat(id), name, count(*),\'cat\' FROM cats GROUP BY name', CreateViewStatement( viewName: 'my_complex_view', columns: ['ids', 'name', 'count', 'type'], ifNotExists: true, query: CompoundSelectStatement( base: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'group_concat', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'id')], ), ), ), ExpressionResultColumn( expression: Reference(columnName: 'name'), ), ExpressionResultColumn( expression: FunctionExpression( name: 'count', parameters: StarFunctionParameter(), ), ), ExpressionResultColumn( expression: StringLiteral(stringLiteral('dog')), ), ], from: TableReference('dogs'), groupBy: GroupBy( by: [Reference(columnName: 'name')], ), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.union, select: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'group_concat', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'id')], ), ), ), ExpressionResultColumn( expression: Reference(columnName: 'name'), ), ExpressionResultColumn( expression: FunctionExpression( name: 'count', parameters: StarFunctionParameter(), ), ), ExpressionResultColumn( expression: StringLiteral(stringLiteral('cat')), ) ], from: TableReference('cats'), groupBy: GroupBy( by: [Reference(columnName: 'name')], ), ), ) ], ), ), ); }); } test/parser/delete_test.dart 644 0 0 1364 14155120333 14313 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses delete statements', () { testStatement( 'DELETE FROM tbl WHERE id = 5', DeleteStatement( from: TableReference('tbl'), where: BinaryExpression( Reference(columnName: 'id'), token(TokenType.equal), NumericLiteral( 5, token(TokenType.numberLiteral), ), ), ), ); }); test('parses delete statements with RETURNING', () { testStatement( 'DELETE FROM tbl RETURNING *;', DeleteStatement( from: TableReference('tbl'), returning: Returning([StarResultColumn()]), ), ); }); } test/parser/insert_test.dart 644 0 0 14750 14131303604 14376 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses insert statements', () { testStatement( 'INSERT OR REPLACE INTO tbl (a, b, c) VALUES (d, e, f)', InsertStatement( mode: InsertMode.insertOrReplace, table: TableReference('tbl'), targetColumns: [ Reference(columnName: 'a'), Reference(columnName: 'b'), Reference(columnName: 'c'), ], source: ValuesSource([ Tuple(expressions: [ Reference(columnName: 'd'), Reference(columnName: 'e'), Reference(columnName: 'f'), ]), ]), ), ); }); test('insert statement with default values', () { testStatement( 'INSERT INTO tbl DEFAULT VALUES', InsertStatement( mode: InsertMode.insert, table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), ), ); }); test('insert statement with select as source', () { testStatement( 'REPLACE INTO tbl SELECT * FROM tbl', InsertStatement( mode: InsertMode.replace, table: TableReference('tbl'), targetColumns: const [], source: SelectInsertSource( SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ), ); }); group('parses upsert clauses', () { const prefix = 'INSERT INTO tbl DEFAULT VALUES ON CONFLICT'; test('without listing indexed columns', () { testStatement( '$prefix DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause([UpsertClauseEntry(action: DoNothing())]), ), ); }); test('listing indexed columns without where clause', () { testStatement( '$prefix (foo, bar DESC) DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [ IndexedColumn(Reference(columnName: 'foo')), IndexedColumn( Reference(columnName: 'bar'), OrderingMode.descending, ), ], action: DoNothing(), ), ], ), ), ); }); test('listing indexed columns and where clause', () { testStatement( '$prefix (foo, bar) WHERE 2 = foo DO NOTHING', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [ IndexedColumn(Reference(columnName: 'foo')), IndexedColumn(Reference(columnName: 'bar')), ], where: BinaryExpression( NumericLiteral(2, token(TokenType.numberLiteral)), token(TokenType.equal), Reference(columnName: 'foo'), ), action: DoNothing(), ), ], ), ), ); }); test('having an update action without where', () { testStatement( '$prefix DO UPDATE SET foo = 2', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( action: DoUpdate( [ SetComponent( column: Reference(columnName: 'foo'), expression: NumericLiteral(2, token(TokenType.numberLiteral)), ), ], ), ), ], ), ), ); }); test('having an update action with where', () { testStatement( '$prefix DO UPDATE SET foo = 2 WHERE ?', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( action: DoUpdate( [ SetComponent( column: Reference(columnName: 'foo'), expression: NumericLiteral(2, token(TokenType.numberLiteral)), ), ], where: NumberedVariable( QuestionMarkVariableToken(fakeSpan('?'), null), ), ), ), ], ), ), ); }); test('having more than one clause', () { testStatement( '$prefix (foo) DO NOTHING ON CONFLICT (bar) DO UPDATE SET x = 2', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), upsert: UpsertClause( [ UpsertClauseEntry( onColumns: [IndexedColumn(Reference(columnName: 'foo'))], action: DoNothing(), ), UpsertClauseEntry( onColumns: [IndexedColumn(Reference(columnName: 'bar'))], action: DoUpdate( [ SetComponent( column: Reference(columnName: 'x'), expression: NumericLiteral(2, token(TokenType.numberLiteral)), ), ], ), ), ], ), ), ); }); }); test('parses RETURNING clause', () { testStatement( 'INSERT INTO tbl DEFAULT VALUES RETURNING foo, 3, bar;', InsertStatement( table: TableReference('tbl'), targetColumns: const [], source: DefaultValues(), returning: Returning([ ExpressionResultColumn(expression: Reference(columnName: 'foo')), ExpressionResultColumn( expression: NumericLiteral(3, token(TokenType.numberLiteral)), ), ExpressionResultColumn(expression: Reference(columnName: 'bar')), ]), ), ); }); } test/parser/select/values_test.dart 644 0 0 3662 13653536125 15646 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses VALUES select statement', () { testStatement( "VALUES ('foo', 'bar'), (1, 2)", ValuesSelectStatement( [ Tuple( expressions: [ StringLiteral(stringLiteral('foo')), StringLiteral(stringLiteral('bar')), ], ), Tuple( expressions: [ NumericLiteral(1, token(TokenType.numberLiteral)), NumericLiteral(2, token(TokenType.numberLiteral)), ], ), ], ), ); }); test('can select FROM VALUES', () { testStatement( 'SELECT * FROM (VALUES(1, 2))', SelectStatement( columns: [StarResultColumn()], from: SelectStatementAsSource( statement: ValuesSelectStatement( [ Tuple( expressions: [ NumericLiteral(1, token(TokenType.numberLiteral)), NumericLiteral(2, token(TokenType.numberLiteral)), ], ), ], ), ), ), ); }); test('can use WITH clause on VALUES', () { testStatement( 'WITH foo AS (VALUES (3)) VALUES(1, 2)', ValuesSelectStatement( [ Tuple( expressions: [ NumericLiteral(1, token(TokenType.numberLiteral)), NumericLiteral(2, token(TokenType.numberLiteral)), ], ), ], withClause: WithClause( recursive: false, ctes: [ CommonTableExpression( cteTableName: 'foo', as: ValuesSelectStatement([ Tuple(expressions: [ NumericLiteral(3, token(TokenType.numberLiteral)) ]), ]), ), ], ), ), ); }); } test/parser/select/common_table_expression_test.dart 644 0 0 5665 14025064205 21257 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses WITH clauses', () { testStatement( ''' WITH RECURSIVE cnt(x) AS ( SELECT 1 UNION ALL SELECT x+1 FROM cnt LIMIT 1000000 ) SELECT x FROM cnt; ''', SelectStatement( withClause: WithClause( recursive: true, ctes: [ CommonTableExpression( cteTableName: 'cnt', columnNames: ['x'], as: CompoundSelectStatement( base: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral( 1, token(TokenType.numberLiteral), ), ), ], ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: BinaryExpression( Reference(columnName: 'x'), token(TokenType.plus), NumericLiteral(1, token(TokenType.numberLiteral)), ), ), ], from: TableReference('cnt'), limit: Limit( count: NumericLiteral( 1000000, token(TokenType.numberLiteral), ), ), ), ), ], ), ), ], ), columns: [ ExpressionResultColumn(expression: Reference(columnName: 'x')), ], from: TableReference('cnt'), ), ); }); test('parses MATERIALIZED / NOT MATERIALIZED clauses', () { testStatement( ''' WITH foo(x) AS MATERIALIZED (SELECT *), bar(x) AS NOT MATERIALIZED (SELECT *) SELECT *; ''', SelectStatement( withClause: WithClause( recursive: false, ctes: [ CommonTableExpression( cteTableName: 'foo', materializationHint: MaterializationHint.materialized, columnNames: ['x'], as: SelectStatement(columns: [StarResultColumn()]), ), CommonTableExpression( cteTableName: 'bar', materializationHint: MaterializationHint.notMaterialized, columnNames: ['x'], as: SelectStatement(columns: [StarResultColumn()]), ), ], ), columns: [StarResultColumn()], ), ); }); } test/parser/select/compound_test.dart 644 0 0 2122 14107761157 16161 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses compound select statements', () { testStatement( 'SELECT * FROM tbl UNION ALL SELECT 1 EXCEPT SELECT 2', CompoundSelectStatement( base: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(1, token(TokenType.numberLiteral)), ), ], ), ), CompoundSelectPart( mode: CompoundSelectMode.except, select: SelectStatement( columns: [ ExpressionResultColumn( expression: NumericLiteral(2, token(TokenType.numberLiteral)), ), ], ), ), ], ), ); }); } test/parser/select/nested_query_test.dart 644 0 0 2167 14206505103 17040 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses nested query statements', () { final stmt = SqlEngine(EngineOptions(useDriftExtensions: true)) .parse('SELECT LIST(SELECT * FROM test) FROM test') .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.columns[0], NestedQueryColumn( select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('test'), ), ), ); }); test('parses nested query statements with as', () { final stmt = SqlEngine(EngineOptions(useDriftExtensions: true)) .parse('SELECT LIST(SELECT * FROM test) AS newname FROM test') .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.columns[0], NestedQueryColumn( as: 'newname', select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('test'), ), ), ); }); } test/parser/select/group_by_test.dart 644 0 0 1351 14155120333 16152 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses group by statements', () { final stmt = SqlEngine() .parse("SELECT * FROM test GROUP BY country HAVING country LIKE '%G%'") .rootNode as SelectStatement; enforceHasSpan(stmt); return enforceEqual( stmt.groupBy!, GroupBy( by: [Reference(columnName: 'country')], having: StringComparisonExpression( left: Reference(columnName: 'country'), operator: token(TokenType.like), right: StringLiteral.from(token(TokenType.stringLiteral), '%G%'), ), ), ); }); } test/parser/select/limit_test.dart 644 0 0 3326 14155120333 15446 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { group('limit clauses', () { test('with just a limit', () { final select = SqlEngine() .parse('SELECT * FROM test LIMIT 5 * 3') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: BinaryExpression( NumericLiteral(5, token(TokenType.numberLiteral)), token(TokenType.star), NumericLiteral(3, token(TokenType.numberLiteral)), ), ), ); }); test('with offset', () { final select = SqlEngine() .parse('SELECT * FROM test LIMIT 10 OFFSET 2') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: NumericLiteral(10, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(2, token(TokenType.numberLiteral)), ), ); }); test('with offset as comma', () { // with the comma notation, the offset comes first. // https://www.sqlite.org/lang_select.html#limitoffset final select = SqlEngine() .parse('SELECT * FROM test LIMIT 10, 2') .rootNode as SelectStatement; enforceHasSpan(select); enforceEqual( select.limit!, Limit( count: NumericLiteral(2, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.comma), offset: NumericLiteral(10, token(TokenType.numberLiteral)), ), ); }); }); } test/parser/select/generic_test.dart 644 0 0 3240 14107761157 15753 0ustar0 pubpubimport 'package:sqlparser/src/ast/ast.dart'; import '../utils.dart'; final Map testCases = { 'SELECT tbl.*, *, 1 as name WHERE 1 ORDER BY name ASC LIMIT 3 OFFSET 5': SelectStatement( columns: [ StarResultColumn('tbl'), StarResultColumn(null), ExpressionResultColumn( expression: NumericLiteral(1, token(TokenType.numberLiteral)), as: 'name', ), ], where: NumericLiteral(1, token(TokenType.numberLiteral)), orderBy: OrderBy(terms: [ OrderingTerm( expression: Reference(columnName: 'name'), orderingMode: OrderingMode.ascending, ), ]), limit: Limit( count: NumericLiteral(3, token(TokenType.numberLiteral)), offsetSeparator: token(TokenType.offset), offset: NumericLiteral(5, token(TokenType.numberLiteral)), ), ), 'SELECT tbl.*, (SELECT * FROM table2) FROM tbl': SelectStatement( columns: [ StarResultColumn('tbl'), ExpressionResultColumn( expression: SubQuery( select: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('table2'), ), ), ), ], from: TableReference('tbl'), ), 'SELECT * FROM tbl WHERE id IN ()': SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), where: InExpression( left: Reference(columnName: 'id'), inside: Tuple(expressions: []), ), ), 'SELECT rowid FROM tbl': SelectStatement( columns: [ ExpressionResultColumn(expression: Reference(columnName: 'rowid')), ], from: TableReference('tbl'), ), }; void main() { testAll(testCases); } test/parser/select/from_test.dart 644 0 0 12657 14155120333 15322 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void _enforceFrom(SelectStatement stmt, Queryable expected) { enforceHasSpan(stmt); enforceEqual(stmt.from!, expected); } void main() { group('from', () { test('a simple table', () { final stmt = SqlEngine().parse('SELECT * FROM tbl').rootNode as SelectStatement; _enforceFrom(stmt, TableReference('tbl')); }); test('schema name and alias', () { final stmt = SqlEngine().parse('SELECT * FROM main.tbl foo').rootNode as SelectStatement; _enforceFrom(stmt, TableReference('tbl', schemaName: 'main', as: 'foo')); }); test('from more than one table', () { final stmt = SqlEngine() .parse('SELECT * FROM tbl AS test, table2') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('tbl', as: 'test'), joins: [ Join( operator: JoinOperator.comma, query: TableReference('table2'), ), ], ), ); }); test('more than one table with ON constraint', () { final stmt = SqlEngine() .parse('SELECT * FROM tbl AS test, table2 ON TRUE') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('tbl', as: 'test'), joins: [ Join( operator: JoinOperator.comma, query: TableReference('table2'), constraint: OnConstraint( expression: BooleanLiteral.withTrue(token(TokenType.$true)), ), ), ], ), ); }); test('inner select statements', () { final stmt = SqlEngine() .parse( 'SELECT * FROM table1, (SELECT * FROM table2 WHERE a) as "inner"') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('table1'), joins: [ Join( operator: JoinOperator.comma, query: SelectStatementAsSource( statement: SelectStatement( columns: [StarResultColumn(null)], from: TableReference('table2'), where: Reference(columnName: 'a'), ), as: 'inner', ), ), ], ), ); }); test('inner compound select statements', () { final stmt = SqlEngine() .parse('SELECT SUM(*) FROM (SELECT COUNT(*) FROM table1 UNION ALL ' 'SELECT COUNT(*) from table2)') .rootNode as SelectStatement; final countStar = ExpressionResultColumn( expression: FunctionExpression( name: 'COUNT', parameters: StarFunctionParameter(), ), ); _enforceFrom( stmt, SelectStatementAsSource( statement: CompoundSelectStatement( base: SelectStatement( columns: [countStar], from: TableReference('table1'), ), additional: [ CompoundSelectPart( mode: CompoundSelectMode.unionAll, select: SelectStatement( columns: [countStar], from: TableReference('table2'), ), ), ], ), ), ); }); test('from a join', () { final stmt = SqlEngine() .parse('SELECT * FROM table1 ' 'INNER JOIN table2 USING (test) ' 'LEFT OUTER JOIN table3 ON TRUE') .rootNode as SelectStatement; _enforceFrom( stmt, JoinClause( primary: TableReference('table1'), joins: [ Join( operator: JoinOperator.inner, query: TableReference('table2'), constraint: UsingConstraint(columnNames: ['test']), ), Join( operator: JoinOperator.leftOuter, query: TableReference('table3'), constraint: OnConstraint( expression: BooleanLiteral.withTrue(token(TokenType.$true)), ), ), ], ), ); }); test('table valued function', () { testStatement( ''' SELECT DISTINCT user.name FROM user, json_each(user.phone) WHERE json_each.value LIKE '704-%'; ''', SelectStatement( distinct: true, columns: [ ExpressionResultColumn( expression: Reference(entityName: 'user', columnName: 'name'), ), ], from: JoinClause( primary: TableReference('user'), joins: [ Join( operator: JoinOperator.comma, query: TableValuedFunction( 'json_each', ExprFunctionParameters(parameters: [ Reference(entityName: 'user', columnName: 'phone') ]), ), ), ], ), where: StringComparisonExpression( left: Reference(entityName: 'json_each', columnName: 'value'), operator: token(TokenType.like), right: StringLiteral(stringLiteral('704-%')), ), ), ); }); }); } test/parser/select/order_by_test.dart 644 0 0 2657 14206505103 16142 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import '../utils.dart'; void main() { test('parses order by clauses', () { final parsed = SqlEngine() .parse('SELECT * FROM tbl ORDER BY -a, b DESC') .rootNode as SelectStatement; enforceHasSpan(parsed); enforceEqual( parsed.orderBy!, OrderBy( terms: [ OrderingTerm( expression: UnaryExpression( token(TokenType.minus), Reference(columnName: 'a'), ), ), OrderingTerm( orderingMode: OrderingMode.descending, expression: Reference(columnName: 'b'), ), ], ), ); }); test('parses clauses with NULLS FIRST or NULLS LAST', () { final parsed = SqlEngine(EngineOptions(useDriftExtensions: true)) .parse(r'SELECT * FROM tbl ORDER BY $a NULLS LAST, b NULLS FIRST') .rootNode as SelectStatement; enforceHasSpan(parsed); enforceEqual( parsed.orderBy!, OrderBy( terms: [ OrderingTerm( expression: DartExpressionPlaceholder(name: 'a'), nulls: OrderingBehaviorForNulls.last, ), OrderingTerm( expression: Reference(columnName: 'b'), nulls: OrderingBehaviorForNulls.first, ), ], ), ); }); } test/parser/multiple_statements.dart 644 0 0 4522 14206507062 16120 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('can parse multiple statements', () { const sql = 'a: UPDATE tbl SET a = b; b: SELECT * FROM tbl;'; testDriftFile( sql, DriftFile([ DeclaredStatement( SimpleName('a'), UpdateStatement( table: TableReference('tbl'), set: [ SetComponent( column: Reference(columnName: 'a'), expression: Reference(columnName: 'b'), ), ], ), ), DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ]), ); }); test('recovers from invalid statements', () { const sql = 'a: UPDATE tbl SET a = * d; b: SELECT * FROM tbl;'; final tokens = Scanner(sql).scanTokens(); final statements = Parser(tokens).driftFile().statements; expect(statements, hasLength(1)); enforceEqual( statements[0], DeclaredStatement( SimpleName('b'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ); }); test('parses imports and declared statements in drift mode', () { const sql = r''' import 'test.dart'; query: SELECT * FROM tbl; '''; final tokens = Scanner(sql, scanDriftTokens: true).scanTokens(); final statements = Parser(tokens, useDrift: true).driftFile().statements; expect(statements, hasLength(2)); final parsedImport = statements[0] as ImportStatement; enforceEqual(parsedImport, ImportStatement('test.dart')); expect(parsedImport.importToken, tokens[0]); expect(parsedImport.importString, tokens[1]); expect(parsedImport.semicolon, tokens[2]); final declared = statements[1] as DeclaredStatement; enforceEqual( declared, DeclaredStatement( SimpleName('query'), SelectStatement( columns: [StarResultColumn(null)], from: TableReference('tbl'), ), ), ); }); } test/parser/partition_test.dart 644 0 0 5132 14211623610 15056 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map _testCases = { 'row_number() OVER (ORDER BY y)': WindowFunctionInvocation( function: identifier('row_number'), parameters: ExprFunctionParameters(), windowDefinition: WindowDefinition( frameSpec: FrameSpec(), orderBy: OrderBy(terms: [ OrderingTerm(expression: Reference(columnName: 'y')), ]), ), ), 'row_number(*) FILTER (WHERE 1) OVER ' '(base_name PARTITION BY a, b ' 'GROUPS BETWEEN UNBOUNDED PRECEDING AND 3 FOLLOWING EXCLUDE TIES)': WindowFunctionInvocation( function: identifier('row_number'), parameters: StarFunctionParameter(), filter: NumericLiteral(1, token(TokenType.numberLiteral)), windowDefinition: WindowDefinition( baseWindowName: 'base_name', partitionBy: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], frameSpec: FrameSpec( type: FrameType.groups, start: FrameBoundary.unboundedPreceding(), end: FrameBoundary.following( NumericLiteral(3, token(TokenType.numberLiteral)), ), excludeMode: ExcludeMode.ties, ), ), ), 'row_number() OVER (RANGE CURRENT ROW EXCLUDE NO OTHERS)': WindowFunctionInvocation( function: identifier('row_number'), parameters: ExprFunctionParameters(), windowDefinition: WindowDefinition( frameSpec: FrameSpec( type: FrameType.range, start: FrameBoundary.currentRow(), end: FrameBoundary.currentRow(), excludeMode: ExcludeMode.noOthers, ), ), ), 'COUNT(is_skipped) FILTER (WHERE is_skipped = true)': AggregateFunctionInvocation( function: identifier('COUNT'), parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'is_skipped')], ), filter: BinaryExpression( Reference(columnName: 'is_skipped'), token(TokenType.equal), BooleanLiteral.withTrue(token(TokenType.$true)), ), ), }; void main() { group('partition parses', () { _testCases.forEach((sql, expected) { test(sql, () { final scanner = Scanner(sql); final tokens = scanner.scanTokens(); final parser = Parser(tokens); final expression = parser.expression(); enforceHasSpan(expression); enforceEqual(expression, expected); }); }); }); } test/parser/expression_test.dart 644 0 0 15304 14155120333 15267 0ustar0 pubpubimport 'package:sqlparser/src/ast/ast.dart'; import 'package:sqlparser/src/reader/parser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map _testCases = { '3 * 7 + 1 NOT BETWEEN 31 AND 74': BetweenExpression( not: true, check: BinaryExpression( BinaryExpression( NumericLiteral(3, token(TokenType.numberLiteral)), token(TokenType.star), NumericLiteral(7, token(TokenType.numberLiteral)), ), token(TokenType.plus), NumericLiteral(1, token(TokenType.numberLiteral)), ), lower: NumericLiteral(31, token(TokenType.numberLiteral)), upper: NumericLiteral(74, token(TokenType.numberLiteral)), ), '3 * 4 + 5 == COUNT(*)': BinaryExpression( BinaryExpression( BinaryExpression( NumericLiteral(3, token(TokenType.numberLiteral)), token(TokenType.star), NumericLiteral(4, token(TokenType.numberLiteral)), ), token(TokenType.plus), NumericLiteral(5, token(TokenType.numberLiteral)), ), token(TokenType.doubleEqual), FunctionExpression( name: 'COUNT', parameters: StarFunctionParameter(), ), ), '? * ?3 + ?2 == :test': BinaryExpression( BinaryExpression( BinaryExpression( NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), token(TokenType.star), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?3'), 3)), ), token(TokenType.plus), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?2'), 2)), ), token(TokenType.doubleEqual), ColonNamedVariable(ColonVariableToken(fakeSpan(':test'), ':test')), ), 'CASE x WHEN a THEN b WHEN c THEN d ELSE e END': CaseExpression( base: Reference(columnName: 'x'), whens: [ WhenComponent( when: Reference(columnName: 'a'), then: Reference(columnName: 'b'), ), WhenComponent( when: Reference(columnName: 'c'), then: Reference(columnName: 'd'), ), ], elseExpr: Reference(columnName: 'e'), ), 'CASE WHEN a THEN ' 'CASE WHEN b THEN c ELSE d END ' 'ELSE ' 'CASE WHEN e THEN f ELSE g END ' 'END': CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'a'), then: CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'b'), then: Reference(columnName: 'c'), ), ], elseExpr: Reference(columnName: 'd'), ), ), ], elseExpr: CaseExpression( whens: [ WhenComponent( when: Reference(columnName: 'e'), then: Reference(columnName: 'f'), ), ], elseExpr: Reference(columnName: 'g'), ), ), "x NOT LIKE '%A%\$' ESCAPE '\$'": StringComparisonExpression( not: true, left: Reference(columnName: 'x'), operator: token(TokenType.like), right: StringLiteral.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'), ), ), ), '(SELECT x)': SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'x'), ), ], ), ), "'hello' || 'world' COLLATE NOCASE": BinaryExpression( StringLiteral.from(token(TokenType.stringLiteral), 'hello'), token(TokenType.doublePipe), CollateExpression( operator: token(TokenType.collate), inner: StringLiteral.from(token(TokenType.stringLiteral), 'world'), collateFunction: token(TokenType.identifier), ), ), 'x in ?': InExpression( left: Reference(columnName: 'x'), inside: NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), ), 'x IN (SELECT col FROM tbl)': InExpression( left: Reference(columnName: 'x'), inside: SubQuery( select: SelectStatement( columns: [ ExpressionResultColumn( expression: Reference(columnName: 'col'), ) ], from: TableReference('tbl'), ), ), ), 'x IN (1, 2, (SELECT 3))': InExpression( left: Reference(columnName: 'x'), inside: Tuple( expressions: [ NumericLiteral(1.0, token(TokenType.numberLiteral)), NumericLiteral(2.0, token(TokenType.numberLiteral)), SubQuery( select: SelectStatement(columns: [ ExpressionResultColumn( expression: NumericLiteral(3.0, token(TokenType.numberLiteral)), ), ]), ), ], ), ), 'CAST(3 + 4 AS TEXT)': CastExpression( BinaryExpression( NumericLiteral(3.0, token(TokenType.numberLiteral)), token(TokenType.plus), NumericLiteral(4.0, token(TokenType.numberLiteral)), ), 'TEXT', ), 'foo ISNULL': IsNullExpression(Reference(columnName: 'foo')), 'foo NOTNULL': IsNullExpression(Reference(columnName: 'foo'), true), 'CURRENT_TIME': TimeConstantLiteral( TimeConstantKind.currentTime, token(TokenType.currentTime)), 'CURRENT_TIMESTAMP': TimeConstantLiteral( TimeConstantKind.currentTimestamp, token(TokenType.currentTimestamp)), 'CURRENT_DATE': TimeConstantLiteral( TimeConstantKind.currentDate, token(TokenType.currentDate)), '(1, 2, 3) > (?, ?, ?)': BinaryExpression( Tuple(expressions: [ for (var i = 1; i <= 3; i++) NumericLiteral(i, token(TokenType.numberLiteral)), ]), token(TokenType.more), Tuple(expressions: [ NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), NumberedVariable(QuestionMarkVariableToken(fakeSpan('?'), null)), ]), ), 'RAISE(IGNORE)': RaiseExpression(RaiseKind.ignore), "RAISE(ROLLBACK, 'Not allowed')": RaiseExpression(RaiseKind.rollback, 'Not allowed'), 'foo': Reference(columnName: 'foo'), 'foo.bar': Reference(entityName: 'foo', columnName: 'bar'), 'foo.bar.baz': Reference( schemaName: 'foo', entityName: 'bar', columnName: 'baz', ), }; void main() { group('expresssion test cases', () { _testCases.forEach((sql, expected) { test(sql, () { final scanner = Scanner(sql); final tokens = scanner.scanTokens(); final parser = Parser(tokens); final expression = parser.expression(); enforceHasSpan(expression); enforceEqual(expression, expected); }); }); }); } test/parser/utils.dart 644 0 0 4174 14206507007 13160 0ustar0 pubpubimport 'package:collection/collection.dart' show IterableExtension; import 'package:source_span/source_span.dart'; import 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; export 'package:sqlparser/src/reader/tokenizer/token.dart'; final defaultSpan = fakeSpan('fake'); Token token(TokenType type) { return Token(type, defaultSpan); } StringLiteralToken stringLiteral(String value) { return StringLiteralToken(value, defaultSpan); } InlineDartToken inlineDart(String dartCode) { return InlineDartToken(fakeSpan('`$dartCode`')); } IdentifierToken identifier(String content) { return IdentifierToken(false, fakeSpan(content)); } DriftFile parseDrift(String content) { return SqlEngine(EngineOptions(useDriftExtensions: true)) .parseDriftFile(content) .rootNode as DriftFile; } void testDriftFile(String driftFile, DriftFile expected) { final parsed = parseDrift(driftFile); enforceHasSpan(parsed); enforceEqual(parsed, expected); } void testStatement(String sql, AstNode expected, {bool driftMode = false}) { final result = SqlEngine(EngineOptions(useDriftExtensions: driftMode)).parse(sql); expect(result.errors, isEmpty); final parsed = result.rootNode; enforceHasSpan(parsed); enforceEqual(parsed, expected); } FileSpan fakeSpan(String content) { return SourceFile.fromString(content).span(0); } void testAll(Map testCases) { testCases.forEach((sql, expected) { test('with $sql', () { testStatement(sql, expected); }); }); } /// The parser should make sure [AstNode.hasSpan] is true on relevant nodes. void enforceHasSpan(AstNode node) { final problematic = [node] .followedBy(node.allDescendants) .firstWhereOrNull((node) => !node.hasSpan && !node.synthetic); if (problematic != null) { throw ArgumentError('Node $problematic did not have a span'); } } void enforceError(String sql, Matcher textMatcher) { final parsed = SqlEngine().parse(sql); expect( parsed.errors, contains( isA().having((e) => e.message, 'message', textMatcher)), ); } test/parser/regression_978_test.dart 644 0 0 1534 14206507123 15642 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses CREATE TABLE statement', () { testStatement( 'CREATE TABLE \"sample_table\" (' 'id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, sample VARCHAR NULL)', CreateTableStatement( tableName: 'sample_table', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [ NotNull(null), PrimaryKeyColumn(null, autoIncrement: true), ], ), ColumnDefinition( columnName: 'sample', typeName: 'VARCHAR', constraints: [ NullColumnConstraint(null), ], ), ], ), driftMode: true, ); }); } test/parser/recovery_test.dart 644 0 0 3351 14206507117 14713 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses create table statements with a previous malformed inport', () { final file = parseDrift(''' import ; CREATE TABLE foo (name TEXT); '''); expect( file.childNodes, contains(const TypeMatcher())); }); test('recovers from parsing errors in column definition', () { final file = parseDrift(''' CREATE TABLE foo ( id INTEGER PRIMARY, name TEXT NOT NULL ); '''); final stmt = file.childNodes.single as CreateTableStatement; enforceEqual( stmt, CreateTableStatement( tableName: 'foo', columns: [ // id column can't be parsed because of the missing KEY ColumnDefinition( columnName: 'name', typeName: 'TEXT', constraints: [NotNull(null)], ), ], ), ); }); test('parses trailing comma with error', () { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)); final result = engine.parseDriftFile(''' CREATE TABLE foo ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, ); '''); expect(result.errors, hasLength(1)); enforceEqual( result.rootNode.childNodes.single, CreateTableStatement( tableName: 'foo', columns: [ ColumnDefinition( columnName: 'id', typeName: 'INTEGER', constraints: [PrimaryKeyColumn(null)], ), ColumnDefinition( columnName: 'name', typeName: 'TEXT', constraints: [NotNull(null)], ), ], ), ); }); } test/parser/misc_test.dart 644 0 0 1730 14131303604 13777 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { group('BEGIN', () { test('without mode', () { testStatement('BEGIN;', BeginTransactionStatement()); testStatement('BEGIN TRANSACTION;', BeginTransactionStatement()); }); test('deferred', () { testStatement('BEGIN DEFERRED;', BeginTransactionStatement(TransactionMode.deferred)); }); test('immediate', () { testStatement('BEGIN IMMEDIATE;', BeginTransactionStatement(TransactionMode.immediate)); }); test('exclusive', () { testStatement('BEGIN EXCLUSIVE TRANSACTION;', BeginTransactionStatement(TransactionMode.exclusive)); }); }); test('COMMIT', () { testStatement('COMMIT', CommitStatement()); testStatement('END', CommitStatement()); testStatement('COMMIT TRANSACTION', CommitStatement()); testStatement('END TRANSACTION', CommitStatement()); }); } test/parser/regression_909_test.dart 644 0 0 4270 14000111271 15617 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; // ignore_for_file: lines_longer_than_80_chars void main() { const stmts = [ 'CREATE TABLE plots (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, name VARCHAR NOT NULL, crop VARCHAR NOT NULL, crop_variety VARCHAR NOT NULL, planting_date INTEGER NOT NULL, is_outdoor_trial INTEGER NOT NULL CHECK (is_outdoor_trial in (0, 1)), uses_crop_blanket INTEGER NOT NULL CHECK (uses_crop_blanket in (0, 1)), is_raised_bed INTEGER NOT NULL CHECK (is_raised_bed in (0, 1)), plant_spacing REAL NOT NULL, row_spacing REAL NOT NULL, irrigation_type VARCHAR NOT NULL, rows_per_bed REAL NULL, bed_spacing REAL NULL, coordinates VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE lab_reports (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, sample_date INTEGER NOT NULL, source VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE dissipated_active_ingredients (id VARCHAR NOT NULL, lab_report_id VARCHAR NOT NULL, active_ingredient_id VARCHAR NULL, name VARCHAR NULL, residue REAL NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE sprays (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, create_date INTEGER NOT NULL, application_method VARCHAR NOT NULL, growth_stage VARCHAR NOT NULL, PRIMARY KEY (id))', 'CREATE TABLE products (id VARCHAR NOT NULL, trade_name VARCHAR NOT NULL, type VARCHAR NOT NULL, owner_id VARCHAR NULL, PRIMARY KEY (id))', 'CREATE TABLE markets (owner_id VARCHAR NOT NULL, deleted INTEGER NOT NULL, last_synced INTEGER NULL, last_modified INTEGER NOT NULL, id VARCHAR NOT NULL, name VARCHAR NOT NULL, mrl REAL NOT NULL, arfd REAL NOT NULL, adi REAL NOT NULL, total_active_ingredients INTEGER NOT NULL, PRIMARY KEY (id))', ]; test('parses statements', () { final engine = SqlEngine(); for (final stmt in stmts) { final result = engine.parse(stmt); expect(result.errors, isEmpty); expect(result.rootNode, isA()); } }); } test/parser/update_test.dart 644 0 0 5355 14155120333 14337 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; final Map testCases = { 'UPDATE OR ROLLBACK tbl SET a = NULL, b = c WHERE d': UpdateStatement( or: FailureMode.rollback, table: TableReference('tbl'), set: [ 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('parses updates with FROM clause', () { testStatement( ''' UPDATE inventory SET quantity = quantity - daily.amt FROM (SELECT sum(quantity) AS amt, itemId FROM sales GROUP BY 2) AS daily WHERE inventory.itemId = daily.itemId; ''', UpdateStatement( table: TableReference('inventory'), set: [ SetComponent( column: Reference(columnName: 'quantity'), expression: BinaryExpression( Reference(columnName: 'quantity'), token(TokenType.minus), Reference(entityName: 'daily', columnName: 'amt'), ), ), ], from: SelectStatementAsSource( statement: SelectStatement( columns: [ ExpressionResultColumn( expression: FunctionExpression( name: 'sum', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'quantity')], ), ), as: 'amt', ), ExpressionResultColumn( expression: Reference(columnName: 'itemId'), ), ], from: TableReference('sales'), groupBy: GroupBy( by: [NumericLiteral(2, token(TokenType.numberLiteral))], ), ), as: 'daily', ), where: BinaryExpression( Reference(entityName: 'inventory', columnName: 'itemId'), token(TokenType.equal), Reference(entityName: 'daily', columnName: 'itemId'), ), ), ); }); test('parses updates with RETURNING clause', () { testStatement( 'UPDATE tbl SET foo = bar RETURNING *', UpdateStatement( table: TableReference('tbl'), set: [ SetComponent( column: Reference(columnName: 'foo'), expression: Reference(columnName: 'bar'), ), ], returning: Returning([StarResultColumn()]), ), ); }); } test/parser/errors_test.dart 644 0 0 343 14131303604 14337 0ustar0 pubpubimport 'package:test/test.dart'; import 'utils.dart'; void main() { test('WITH without following statement', () { enforceError('WITH foo AS (SELECT * FROM bar)', contains('to follow this WITH clause')); }); } test/parser/create_trigger_test.dart 644 0 0 4220 14014446300 16030 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; final _block = Block([ UpdateStatement(table: TableReference('tbl'), set: [ SetComponent( column: Reference(columnName: 'foo'), expression: Reference(columnName: 'bar'), ), ]), SelectStatement( columns: [StarResultColumn()], from: TableReference('tbl'), ), ]); void main() { test('parses create trigger statements', () { const sql = ''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER DELETE ON tbl FOR EACH ROW BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( ifNotExists: true, triggerName: 'my_trigger', mode: TriggerMode.after, target: DeleteTarget(), onTable: TableReference('tbl'), action: _block, ), ); }); test('with INSTEAD OF mode and UPDATE', () { const sql = ''' CREATE TRIGGER my_trigger INSTEAD OF UPDATE OF foo, bar ON tbl BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( triggerName: 'my_trigger', mode: TriggerMode.insteadOf, target: UpdateTarget([ Reference(columnName: 'foo'), Reference(columnName: 'bar'), ]), onTable: TableReference('tbl'), action: _block, ), ); }); test('with BEFORE, INSERT and WHEN clause', () { const sql = ''' CREATE TRIGGER my_trigger BEFORE INSERT ON tbl WHEN new.foo IS NULL BEGIN UPDATE tbl SET foo = bar; SELECT * FROM tbl; END; '''; testStatement( sql, CreateTriggerStatement( triggerName: 'my_trigger', mode: TriggerMode.before, target: InsertTarget(), onTable: TableReference('tbl'), when: IsExpression( false, Reference(entityName: 'new', columnName: 'foo'), NullLiteral(token(TokenType.$null)), ), action: _block, ), ); }); } test/parser/regression_891_test.dart 644 0 0 4032 14107761157 15641 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; ColonVariableToken _colon(String name) { return ColonVariableToken(fakeSpan(name), name); } void main() { final caseExpr = CaseExpression( whens: [ WhenComponent( when: BinaryExpression( NumericLiteral(1, token(TokenType.numberLiteral)), token(TokenType.equal), ColonNamedVariable(_colon(':isReviewFolderSelected')), ), then: IsExpression( true, Reference(entityName: 'n', columnName: 'nextReviewTime'), NullLiteral(token(TokenType.$null)), ), ), ], elseExpr: IsExpression( false, Reference(entityName: 'n', columnName: 'nextReviewTime'), NullLiteral(token(TokenType.$null)), ), ); final folderExpr = BinaryExpression( Reference(entityName: 'n', columnName: 'folderId'), token(TokenType.equal), ColonNamedVariable(_colon(':selectedFolderId')), ); test('repro 1', () { testStatement( ''' SELECT * FROM notes n WHERE CASE WHEN 1 = :isReviewFolderSelected THEN n.nextReviewTime IS NOT NULL ELSE n.nextReviewTime IS NULL END and n.folderId = :selectedFolderId; ''', SelectStatement( from: TableReference('notes', as: 'n'), columns: [StarResultColumn()], where: BinaryExpression( caseExpr, token(TokenType.and), folderExpr, ), ), ); }); test('repro 2', () { testStatement( ''' SELECT * FROM notes n WHERE n.folderId = :selectedFolderId and CASE WHEN 1 = :isReviewFolderSelected THEN n.nextReviewTime IS NOT NULL ELSE n.nextReviewTime IS NULL END; ''', SelectStatement( from: TableReference('notes', as: 'n'), columns: [StarResultColumn()], where: BinaryExpression( folderExpr, token(TokenType.and), caseExpr, ), ), ); }); } test/parser/create_table_test.dart 644 0 0 21646 14213402317 15510 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import '../common_data.dart'; import 'utils.dart'; void main() { test('parsers simple create table statements', () { testStatement( 'CREATE TABLE my_tbl (a INT, b TEXT)', CreateTableStatement(tableName: 'my_tbl', columns: [ ColumnDefinition(columnName: 'a', typeName: 'INT'), ColumnDefinition(columnName: 'b', typeName: 'TEXT'), ]), ); }); test('parses complex CREATE TABLE statements', () { testStatement( createTableStmt, CreateTableStatement( tableName: 'users', ifNotExists: true, withoutRowId: false, columns: [ ColumnDefinition( columnName: 'id', typeName: 'INT', constraints: [ NotNull(null), PrimaryKeyColumn( null, autoIncrement: true, onConflict: ConflictClause.rollback, mode: OrderingMode.descending, ), ], ), ColumnDefinition( columnName: 'email', typeName: 'VARCHAR', constraints: [ NotNull(null), UniqueColumn(null, ConflictClause.abort), ], ), ColumnDefinition( columnName: 'score', typeName: 'INT', constraints: [ NotNull('score set'), Default( null, NumericLiteral(420, token(TokenType.numberLiteral))), CheckColumn( null, BinaryExpression( Reference(columnName: 'score'), token(TokenType.more), NumericLiteral( 0, token(TokenType.numberLiteral), ), ), ), ], ), ColumnDefinition( columnName: 'display_name', typeName: 'VARCHAR', constraints: [ NullColumnConstraint(null), CollateConstraint( null, 'BINARY', ), ForeignKeyColumnConstraint( null, ForeignKeyClause( foreignTable: TableReference('some'), columnNames: [Reference(columnName: 'thing')], onUpdate: ReferenceAction.cascade, onDelete: ReferenceAction.setNull, deferrable: DeferrableClause( false, InitialDeferrableMode.deferred, ), ), ), ], ) ], tableConstraints: [ KeyClause( null, isPrimaryKey: false, columns: [ IndexedColumn(Reference(columnName: 'score')), IndexedColumn(Reference(columnName: 'display_name')), ], onConflict: ConflictClause.abort, ), ForeignKeyTableConstraint( null, columns: [ Reference(columnName: 'id'), Reference(columnName: 'email'), ], clause: ForeignKeyClause( foreignTable: TableReference('another'), columnNames: [ Reference(columnName: 'a'), Reference(columnName: 'b'), ], onDelete: ReferenceAction.noAction, onUpdate: ReferenceAction.restrict, deferrable: DeferrableClause( true, InitialDeferrableMode.immediate, ), ), ) ], ), ); }); test('parses KEY ORDERING in PRIMARY KEY clause', () { testStatement( 'CREATE TABLE a (b TEXT, PRIMARY KEY (b DESC))', CreateTableStatement( tableName: 'a', columns: [ColumnDefinition(columnName: 'b', typeName: 'TEXT')], tableConstraints: [ KeyClause( null, isPrimaryKey: true, columns: [ IndexedColumn( Reference(columnName: 'b'), OrderingMode.descending, ), ], ), ], ), ); }); test('parses GENERATED AS', () { final expr = FunctionExpression( name: 'UPPER', parameters: ExprFunctionParameters( parameters: [Reference(columnName: 'a')], ), ); testStatement( ''' CREATE TABLE a ( a TEXT, b TEXT GENERATED ALWAYS AS (UPPER(a)) STORED, c TEXT GENERATED ALWAYS AS (UPPER(a)) VIRTUAL, d TEXT GENERATED ALWAYS AS (UPPER(a)) ) ''', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'a', typeName: 'TEXT'), ColumnDefinition(columnName: 'b', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: true), ]), ColumnDefinition(columnName: 'c', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: false), ]), ColumnDefinition(columnName: 'd', typeName: 'TEXT', constraints: [ GeneratedAs(expr, stored: false), ]) ], ), ); }); test('parses MAPPED BY constraints when in drift mode', () { testStatement( 'CREATE TABLE a (b NOT NULL MAPPED BY `Mapper()` PRIMARY KEY)', CreateTableStatement(tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: null, constraints: [ NotNull(null), MappedBy(null, inlineDart('Mapper()')), PrimaryKeyColumn(null), ], ), ]), driftMode: true, ); }); test('parses JSON KEY constraints in drift mode', () { testStatement( 'CREATE TABLE a (b INTEGER JSON KEY "my_json_key")', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: 'INTEGER', constraints: [ JsonKey( null, identifier('my_json_key'), ), ], ), ], ), driftMode: true, ); }); test('parses CREATE TABLE WITH in drift more', () { testStatement( 'CREATE TABLE a (b INTEGER) WITH MyExistingClass', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition( columnName: 'b', typeName: 'INTEGER', ), ], driftTableName: DriftTableName('MyExistingClass', true), ), driftMode: true, ); }); test('parses CREATE VIRTUAL TABLE statement', () { testStatement( 'CREATE VIRTUAL TABLE IF NOT EXISTS foo USING bar(a, b(), c) AS drift', CreateVirtualTableStatement( ifNotExists: true, tableName: 'foo', moduleName: 'bar', arguments: [ fakeSpan('a'), fakeSpan('b()'), fakeSpan('c'), ], driftTableName: DriftTableName('drift', false), ), driftMode: true, ); }); test('parses CREATE VIRTUAL TABLE statement without args', () { testStatement( 'CREATE VIRTUAL TABLE foo USING bar;', CreateVirtualTableStatement( tableName: 'foo', moduleName: 'bar', arguments: [], ), ); }); test("can't have empty arguments in CREATE VIRTUAL TABLE", () { final engine = SqlEngine(); expect( engine.parse('CREATE VIRTUAL TABLE foo USING bar(a,)').errors, contains( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at closing bracket', ')'), ), ); expect( engine.parse('CREATE VIRTUAL TABLE foo USING bar(a,,b)').errors, contains( const TypeMatcher() .having((e) => e.token.lexeme, 'fails at next comma', ','), ), ); }); test('parses WITHOUT ROWID and STRICT', () { testStatement( 'CREATE TABLE a (c INTEGER) STRICT, WITHOUT ROWID, STRICT', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'c', typeName: 'INTEGER'), ], withoutRowId: true, isStrict: true, ), ); }); test('parses DEFAULT with a negative literal', () { // regression test for https://github.com/simolus3/drift/discussions/1550 testStatement( 'CREATE TABLE a (b INTEGER NOT NULL DEFAULT -1);', CreateTableStatement( tableName: 'a', columns: [ ColumnDefinition(columnName: 'b', typeName: 'INTEGER', constraints: [ NotNull(null), Default( null, UnaryExpression( Token(TokenType.minus, fakeSpan('-')), NumericLiteral(1, NumericToken(fakeSpan('1'))), ), ) ]) ], ), ); }); } test/parser/create_index_test.dart 644 0 0 3610 13756773720 15523 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('parses CREATE INDEX statements', () { testStatement( 'CREATE INDEX foo ON bar (baz, inga) WHERE TRUE', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn(Reference(columnName: 'baz')), IndexedColumn(Reference(columnName: 'inga')), ], where: BooleanLiteral.withTrue(token(TokenType.$true)), ), ); }); test('with unique and IF NOT EXISTS', () { testStatement( 'CREATE UNIQUE INDEX IF NOT EXISTS foo ON bar (baz);', CreateIndexStatement( unique: true, ifNotExists: true, indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn(Reference(columnName: 'baz')), ], ), ); }); test('can have ordering modes on index expressions', () { testStatement( 'CREATE INDEX foo ON bar (a + b DESC);', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn( BinaryExpression( Reference(columnName: 'a'), token(TokenType.plus), Reference(columnName: 'b'), ), OrderingMode.descending, ), ], ), ); }); test('can have collate expressions', () { testStatement( 'CREATE INDEX foo ON bar (baz COLLATE RTRIM);', CreateIndexStatement( indexName: 'foo', on: TableReference('bar'), columns: [ IndexedColumn( CollateExpression( inner: Reference(columnName: 'baz'), operator: token(TokenType.collate), collateFunction: identifier('RTRIM'), ), ), ], ), ); }); } test/scanner/comments_test.dart 644 0 0 1765 13764474313 15057 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; void main() { test('scanns comments', () { const sql = r''' --line -- line /*c*/ /*multi line */ /* not terminated'''; // using whereType instead of cast because of the invisible eof token final tokens = Scanner(sql).scanTokens().whereType(); expect(tokens.map((t) => t.mode), [ CommentMode.line, CommentMode.line, CommentMode.cStyle, CommentMode.cStyle, CommentMode.cStyle, ]); expect(tokens.map((t) => t.content), [ 'line', ' line', 'c', 'multi\n line ', ' not terminated', ]); }); test('supports -- comments on last line', () { const sql = '-- not much to see'; final tokens = Scanner(sql).scanTokens(); expect(tokens, hasLength(2)); expect((tokens[0] as CommentToken).content, ' not much to see'); expect(tokens[1].type, TokenType.eof); }); } test/scanner/scanner_test.dart 644 0 0 2566 14206507211 14645 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; void main() { test('parses ** as two tokens when not using drift mode', () { final tokens = Scanner('**').scanTokens(); expect(tokens.map((e) => e.type), containsAllInOrder([TokenType.star, TokenType.star])); }); test('throws when seeing an invalid token', () { expect( Scanner('!').scanTokens, throwsA(isA()), ); }); test('scans identifiers with backticks', () { expect( Scanner('`SELECT`').scanTokens(), contains(isA() .having((e) => e.identifier, 'identifier', 'SELECT')), ); }); test('scans identifiers with double quotes', () { expect( Scanner('"SELECT"').scanTokens(), contains(isA() .having((e) => e.identifier, 'identifier', 'SELECT')), ); }); test('scans new tokens for JSON extraction', () { expect(Scanner('- -> ->>').scanTokens(), [ isA().having((e) => e.type, 'tokenType', TokenType.minus), isA().having((e) => e.type, 'tokenType', TokenType.dashRangle), isA() .having((e) => e.type, 'tokenType', TokenType.dashRangleRangle), isA().having((e) => e.type, 'tokenType', TokenType.eof), ]); }); } test/scanner/recognizes_all_tokens_test.dart 644 0 0 3312 14205515465 17576 0ustar0 pubpub@TestOn('vm') import 'dart:convert'; import 'dart:ffi'; import 'package:ffi/ffi.dart'; import 'package:sqlite3/open.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; typedef SqliteKeywordCountNative = Int32 Function(); typedef SqliteKeywordCount = int Function(); typedef SqliteKeywordNameNative = Int32 Function( Int32, Pointer>, Pointer); typedef SqliteKeywordName = int Function( int, Pointer>, Pointer); void main() { String? skip; late DynamicLibrary library; try { library = open.openSqlite(); // Some platforms have sqlite3, but no sqlite3_keyword_count library.lookup('sqlite3_keyword_count'); } on Object { skip = 'sqlite3 is not available in test environment'; } test( 'recognizes all sqlite keywords', () { final keywordCount = library.lookupFunction( 'sqlite3_keyword_count')(); final nameFunction = library.lookupFunction( 'sqlite3_keyword_name'); final charOut = malloc>(); final lengthOut = malloc(); final missingNames = []; for (var i = 0; i < keywordCount; i++) { nameFunction(i, charOut, lengthOut); final bytes = charOut.value.asTypedList(lengthOut.value); final name = utf8.decode(bytes); if (!keywords.containsKey(name)) { missingNames.add(name); } } missingNames.sort(); malloc.free(charOut); malloc.free(lengthOut); expect(missingNames, isEmpty); }, skip: skip, ); } test/scanner/single_token_tests.dart 644 0 0 10262 14155120333 16067 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:test/test.dart'; import '../parser/utils.dart'; void expectFullToken(String token, TokenType type) { final scanner = Scanner(token); List tokens; try { tokens = scanner.scanTokens(); } catch (e, s) { print(e); print(s); fail('Parsing error while parsing $token'); } if (tokens.length != 2 || tokens.last.type != TokenType.eof) { fail('Expected exactly one token when parsing $token, ' 'got ${tokens.length - 1}'); } expect(tokens.first.type, type, reason: '$token is a $type'); expect(tokens.first.span.text, token); } Map testCases = { '(': TokenType.leftParen, ')': TokenType.rightParen, ',': TokenType.comma, '.': TokenType.dot, '+': TokenType.plus, '-': TokenType.minus, '*': TokenType.star, '/': TokenType.slash, '<=': TokenType.lessEqual, '<': TokenType.less, '>=': TokenType.moreEqual, '>': TokenType.more, '!=': TokenType.exclamationEqual, "'hello there'": TokenType.stringLiteral, "''": TokenType.stringLiteral, '1.123': TokenType.numberLiteral, '1.32e5': TokenType.numberLiteral, '.123e-3': TokenType.numberLiteral, '0xFF13': TokenType.numberLiteral, '0Xf13A': TokenType.numberLiteral, 'SELECT': TokenType.select, '"UPDATE"': TokenType.identifier, '@foo': TokenType.atSignVariable, ':named': TokenType.colonVariable, '"spo\uD83C\uDF83ky"': TokenType.identifier, '[account name]': TokenType.identifier, }; void main() { group('single token:', () { for (final entry in testCases.entries) { test('parses ${entry.key}', () { expectFullToken(entry.key, entry.value); }); } }); test('can escape strings', () { final scanner = Scanner("'what''s up'"); scanner.scanTokens(); expect(scanner.tokens, hasLength(2)); // eof token at the end expect( scanner.tokens.first, const TypeMatcher() .having((token) => token.value, 'value', "what's up"), ); expect(scanner.tokens[1].type, TokenType.eof); }); test('issues error for unterminated string literals', () { final scanner = Scanner("'unterminated"); expect(scanner.scanTokens, throwsA(isA())); expect( scanner.errors, contains(const TypeMatcher() .having((e) => e.message, 'message', 'Unterminated string')), ); }); group('parses numeric literals', () { void checkLiteral(String lexeme, NumericToken other, num value) { final scanner = Scanner(lexeme)..scanTokens(); final token = scanner.tokens.first as NumericToken; expect(token.hasSameStructureAs(other), isTrue, reason: '$token should have the same structure as $other'); expect(token.parsedNumber, equals(value)); } test('hexadecimal', () { checkLiteral('0x123', NumericToken(defaultSpan, hexDigits: '123'), 0x123); }); test('integer without exponent', () { checkLiteral( '42', NumericToken(defaultSpan, digitsBeforeDecimal: '42'), 42); }); test('integer, positive exponent', () { checkLiteral( '42E1', NumericToken(defaultSpan, digitsBeforeDecimal: '42', exponent: 1), 420); }); test('integer, negative exponent', () { checkLiteral( '42E-1', NumericToken(defaultSpan, digitsBeforeDecimal: '42', exponent: -1), 4.2); }); test('decimal', () { checkLiteral( '4.2', NumericToken( defaultSpan, digitsBeforeDecimal: '4', digitsAfterDecimal: '2', hasDecimalPoint: true, ), 4.2, ); }); test('decimal, nothing after decimal dot', () { checkLiteral( '4.e2', NumericToken( defaultSpan, digitsBeforeDecimal: '4', exponent: 2, hasDecimalPoint: true, ), 400.0, ); }); test('decimal, nothing before decimal dot', () { checkLiteral( '.2', NumericToken( defaultSpan, digitsAfterDecimal: '2', hasDecimalPoint: true, ), .2, ); }); }); } test/scanner/moor_tokens_test.dart 644 0 0 1472 14206507205 15551 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/scanner.dart'; import 'package:sqlparser/src/reader/tokenizer/token.dart'; import 'package:test/test.dart'; void main() { test('parses drift specific tokens', () { const part = 'c INTEGER MAPPED BY `const Mapper()` NOT NULL **'; final scanner = Scanner(part, scanDriftTokens: true); final tokens = scanner.scanTokens(); expect(scanner.errors, isEmpty); expect(tokens.map((t) => t.type), [ TokenType.identifier, // c TokenType.identifier, // INTEGER TokenType.mapped, TokenType.by, TokenType.inlineDart, // `const Mapper()` TokenType.not, TokenType.$null, TokenType.doubleStar, TokenType.eof, ]); expect( tokens.whereType().single.dartCode, 'const Mapper()'); }); } test/scanner/utils_test.dart 644 0 0 3032 13653536125 14354 0ustar0 pubpubimport 'package:sqlparser/src/reader/tokenizer/utils.dart'; import 'package:test/test.dart'; void main() { test('isDigit', () { expect(isDigit('0'.codeUnitAt(0)), isTrue); expect(isDigit('3'.codeUnitAt(0)), isTrue); expect(isDigit('9'.codeUnitAt(0)), isTrue); expect(isDigit('a'.codeUnitAt(0)), isFalse); expect(isDigit('x'.codeUnitAt(0)), isFalse); }); test('isHexDigit', () { expect(isHexDigit('0'.codeUnitAt(0)), isTrue); expect(isHexDigit('3'.codeUnitAt(0)), isTrue); expect(isHexDigit('9'.codeUnitAt(0)), isTrue); expect(isHexDigit('a'.codeUnitAt(0)), isTrue); expect(isHexDigit('C'.codeUnitAt(0)), isTrue); expect(isHexDigit('F'.codeUnitAt(0)), isTrue); expect(isDigit('x'.codeUnitAt(0)), isFalse); expect(isDigit('G'.codeUnitAt(0)), isFalse); }); test('canStartIdentifier', () { expect(canStartIdentifier('_'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('a'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('C'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('Z'.codeUnitAt(0)), isTrue); expect(canStartIdentifier('['.codeUnitAt(0)), isFalse); expect(canStartIdentifier('0'.codeUnitAt(0)), isFalse); }); test('continuesIdentifier', () { expect(continuesIdentifier('_'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('a'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('Z'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('0'.codeUnitAt(0)), isTrue); expect(continuesIdentifier('['.codeUnitAt(0)), isFalse); }); } test/common_data.dart 644 0 0 1131 14000111271 12755 0ustar0 pubpubconst createTableStmt = ''' CREATE TABLE IF NOT EXISTS users ( id INT NOT NULL PRIMARY KEY DESC ON CONFLICT ROLLBACK AUTOINCREMENT, email VARCHAR NOT NULL UNIQUE ON CONFLICT ABORT, score INT CONSTRAINT "score set" NOT NULL DEFAULT 420 CHECK (score > 0), display_name VARCHAR NULL COLLATE BINARY REFERENCES some(thing) ON UPDATE CASCADE ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED, UNIQUE (score, display_name) ON CONFLICT ABORT, FOREIGN KEY (id, email) REFERENCES another (a, b) ON DELETE NO ACTION ON UPDATE RESTRICT NOT DEFERRABLE INITIALLY IMMEDIATE ) '''; test/utils/node_to_text_test.dart 644 0 0 31437 14211624117 15436 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:sqlparser/utils/node_to_text.dart'; import 'package:test/test.dart'; enum _ParseKind { statement, driftFile } void main() { final engine = SqlEngine(EngineOptions(useDriftExtensions: true)); void testFormat(String input, {_ParseKind kind = _ParseKind.statement}) { AstNode parse(String input) { late ParseResult result; switch (kind) { case _ParseKind.statement: result = engine.parse(input); break; case _ParseKind.driftFile: result = engine.parseDriftFile(input); break; } if (result.errors.isNotEmpty) { fail('Error parsing $input: ${result.errors.join('\n')}'); } return result.rootNode; } final originalAst = parse(input); final formatted = originalAst.toSql(); final newAst = parse(formatted); try { enforceEqual(originalAst, newAst); } catch (e) { fail('Not equal after formatting: $input to $formatted: $e'); } } group('create', () { group('trigger', () { test('before delete', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger BEFORE DELETE ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('instead of insert', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger INSTEAD OF INSERT ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('after update', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER UPDATE ON t1 BEGIN SELECT * FROM t2; END; '''); }); test('after update of when', () { testFormat(''' CREATE TRIGGER IF NOT EXISTS my_trigger AFTER UPDATE OF c1, c2 ON t1 WHEN foo = bar BEGIN SELECT * FROM t2; END; '''); }); test('Using RAISE', () { testFormat(''' CREATE TRIGGER my_trigger AFTER DELETE ON t1 BEGIN SELECT RAISE(ABORT, 'please don''t'); END; '''); }); }); test('view', () { testFormat(''' CREATE VIEW my_view (foo, bar) AS SELECT * FROM t1; '''); testFormat(''' CREATE VIEW my_view AS SELECT * FROM t1; '''); }); group('table', () { test('complex', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo TEXT NOT NULL PRIMARY KEY DEFAULT (3 * 4), baz INT CONSTRAINT not_null NOT NULL PRIMARY KEY AUTOINCREMENT, bar TEXT UNIQUE ON CONFLICT IGNORE CHECK (3 * 4 = 12) DEFAULT 'some string here' COLLATE c REFERENCES t2 (c) ON DELETE RESTRICT ON UPDATE NO ACTION, PRIMARY KEY (foo, bar DESC) ON CONFLICT ABORT, UNIQUE (baz) ON CONFLICT REPLACE, CONSTRAINT my_constraint CHECK(baz < 3), FOREIGN KEY (foo, baz) REFERENCES t2 ON DELETE SET NULL ON UPDATE CASCADE DEFERRABLE INITIALLY IMMEDIATE, FOREIGN KEY (bar) REFERENCES t2 (bax) ON DELETE SET DEFAULT NOT DEFERRABLE ); '''); }); test('WITHOUT ROWID', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) WITHOUT ROWID; '''); }); test('STRICT', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) STRICT; '''); }); test('STRICT and WITHOUT ROWID', () { testFormat(''' CREATE TABLE IF NOT EXISTS my_table( foo INTEGER NOT NULL PRIMARY KEY ASC ) WITHOUT ROWID, STRICT; '''); }); test('virtual', () { testFormat('CREATE VIRTUAL TABLE foo USING bar(a, b, c);'); }); }); test('index', () { testFormat(''' CREATE INDEX my_idx ON t1 (c1, c2, c3); '''); testFormat(''' CREATE UNIQUE INDEX my_idx ON t1 (c1, c2, c3) WHERE c1 < c3; '''); }); }); group('escapes identifiers', () { test("when they're keywords", () { testFormat('SELECT * FROM "create";'); }); test('when they contain whitespace', () { testFormat('SELECT * FROM "my fancy table"'); }); }); group('misc', () { test('transactions', () { testFormat('BEGIN DEFERRED TRANSACTION;'); testFormat('BEGIN IMMEDIATE'); testFormat('BEGIN EXCLUSIVE'); testFormat('COMMIT'); testFormat('END TRANSACTION'); }); }); group('query statements', () { group('select', () { test('with common table expressions', () { testFormat(''' WITH RECURSIVE foo (id) AS (VALUES(1) UNION ALL SELECT id + 1 FROM foo) SELECT * FROM foo; '''); }); test('with materialized CTEs', () { testFormat(''' WITH foo (id) AS NOT MATERIALIZED (SELECT 1), bar (id) AS MATERIALIZED (SELECT 2) SELECT * FROM foo UNION ALL SELECT * FROM bar; '''); }); test('compound', () { testFormat(''' SELECT * FROM foo UNION ALL SELECT * FROM bar UNION SELECT * FROM baz INTERSECT SELECT * FROM bar2 EXCEPT SELECT * FROM bar3 LIMIT 5; '''); }); test('values', () { testFormat('VALUES (1,2,3), (4,5,6);'); }); test('group by', () { testFormat(''' SELECT * FROM foo GROUP BY a, b, c HAVING COUNT(id) > 10 '''); }); test('with windows', () { testFormat(''' SELECT * FROM foo WINDOW my_window AS ( PARTITION BY bar GROUPS BETWEEN 3 PRECEDING AND CURRENT ROW EXCLUDE NO OTHERS ), other AS (my_window ORDER BY foo DESC, bar ASC NULLS FIRST RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW ), yet_another AS (other RANGE CURRENT ROW EXCLUDE GROUP), finally AS (other RANGE BETWEEN CURRENT ROW AND 4 FOLLOWING EXCLUDE TIES ) '''); }); test('aggregate', () { testFormat(''' SELECT subs_id, subs_name, COUNT(is_skipped) FILTER (WHERE is_skipped = true) skipped, COUNT(is_touched) FILTER (WHERE is_touched = true) touched, COUNT(is_passed) FILTER (WHERE is_passed = true) passed FROM stats GROUP BY subs_id; '''); }); test('joins', () { testFormat(''' SELECT * FROM foo AS f, bar NATURAL INNER JOIN j1 USING (foo) LEFT JOIN j2 ON j2.id = bar.c LEFT OUTER JOIN j3 ON j3.id = bar.c CROSS JOIN j4 ON j4.a = j3.b INNER JOIN (SELECT * FROM bar) AS b INNER JOIN table_valued_function(foo) '''); }); test('table references', () { testFormat('SELECT * FROM foo'); testFormat('SELECT * FROM main.foo'); }); test('limit', () { testFormat('SELECT * FROM foo LIMIT 3, 4'); testFormat('SELECT * FROM foo LIMIT 4 OFFSET 3'); }); test('order by', () { testFormat('SELECT foo.* FROM foo ORDER BY foo NULLS FIRST'); }); }); group('delete', () { test('with CTEs', () { testFormat( 'WITH foo (id) AS (SELECT * FROM bar) DELETE FROM bar WHERE x;'); }); test('with returning', () { testFormat('DELETE FROM foo RETURNING *'); }); }); group('insert', () { test('replace', () { testFormat('WITH foo (id) AS (SELECT * FROM bar) ' 'REPLACE INTO foo DEFAULT VALUES'); }); test('into select', () { testFormat('INSERT INTO foo SELECT * FROM bar'); }); test('with returning', () { testFormat('INSERT INTO foo DEFAULT VALUES RETURNING *'); }); test('upsert - do nothing', () { testFormat( 'INSERT OR REPLACE INTO foo DEFAULT VALUES ON CONFLICT DO NOTHING'); }); test('upsert with conflict target', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ON CONFLICT (a, b, c) ' 'DO NOTHING;'); }); test('upsert with conflict target and where', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT (a, b, c) WHERE foo = bar DO NOTHING;'); }); test('upsert - update', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT DO UPDATE SET a = b, c = d WHERE d < a;'); }); test('upsert - multiple clauses', () { testFormat('INSERT INTO foo VALUES (1, 2, 3) ' 'ON CONFLICT DO NOTHING ' 'ON CONFLICT DO UPDATE SET a = b, c = d WHERE d < a;'); }); }); group('update', () { test('simple', () { testFormat('UPDATE foo SET bar = baz WHERE 1;'); }); test('with returning', () { testFormat('UPDATE foo SET bar = baz RETURNING *'); }); const modes = [ 'OR ABORT', 'OR FAIL', 'OR IGNORE', 'OR REPLACE', ' OR ROLLBACK', ]; for (var i = 0; i < modes.length; i++) { test('failure mode #$i', () { testFormat('UPDATE ${modes[i]} foo SET bar = baz'); }); } test('from', () { testFormat('UPDATE foo SET bar = baz FROM t1 CROSS JOIN t2'); }); }); }); group('expressions', () { test('between', () { testFormat('SELECT x BETWEEN a AND b'); testFormat('SELECT x NOT BETWEEN a AND b'); }); test('binary', () { testFormat('SELECT x OR y'); testFormat('SELECT x AND y'); }); test('in', () { testFormat('SELECT x IN (SELECT * FROM foo);'); testFormat('SELECT x NOT IN (SELECT * FROM foo);'); }); test('boolean literals', () { testFormat('SELECT TRUE OR FALSE'); }); test('case', () { testFormat('SELECT CASE WHEN a THEN b ELSE C END'); testFormat('SELECT CASE x WHEN a THEN b WHEN c THEN d END'); }); test('cast', () { testFormat('SELECT CAST(X AS INTEGER)'); }); test('collate', () { testFormat('SELECT x COLLATE y AS xc'); }); test('exists', () { testFormat('SELECT x FROM foo WHERE EXISTS (SELECT * FROM bar)'); }); test('function', () { testFormat('SELECT my_function(*) FROM foo'); testFormat('SELECT my_function(DISTINCT a, b) FROM foo'); testFormat('SELECT my_function(a, b) FROM foo'); }); test('is', () { testFormat('SELECT foo IS bar'); testFormat('SELECT foo IS NOT bar'); }); test('is null', () { testFormat('SELECT foo ISNULL'); testFormat('SELECT foo NOTNULL'); }); test('null literal', () { testFormat('SELECT NULL;'); }); test('parentheses', () { testFormat('SELECT (3 + 4) * 5'); }); test('reference with table', () { testFormat('SELECT foo.bar FROM foo'); }); test('string comparison', () { testFormat('SELECT x LIKE y FROM foo'); }); test('time literals', () { testFormat('SELECT CURRENT_TIME;'); testFormat('SELECT CURRENT_DATE;'); testFormat('SELECT CURRENT_TIMESTAMP;'); }); test('unary expression', () { testFormat('SELECT -(+(~3));'); }); test('references', () { testFormat('SELECT foo'); testFormat('SELECT foo.bar'); testFormat('SELECT foo.bar.baz'); }); test('json', () { testFormat('SELECT a -> b'); testFormat('SELECT a ->> b'); }); }); test('identifiers', () { void testWith(String id, String formatted) { final node = Reference(columnName: id); expect(node.toSql(), formatted); } testWith('a', 'a'); testWith('_', '_'); testWith('c0', 'c0'); testWith('_c0', '_c0'); testWith('a b', '"a b"'); testWith(r'a$b', r'"a$b"'); }); group('drift', () { test('dart placeholders', () { testFormat(r'SELECT $placeholder FROM foo'); }); test('imports', () { testFormat('import \'foo.bar\';', kind: _ParseKind.driftFile); }); test('declared statements', () { testFormat('foo (?1 AS INT): SELECT * FROM bar WHERE ? < 10;', kind: _ParseKind.driftFile); testFormat('foo: SELECT * FROM bar WHERE :id < 10;', kind: _ParseKind.driftFile); testFormat('foo (REQUIRED :x AS TEXT OR NULL): SELECT :x;', kind: _ParseKind.driftFile); testFormat(r'foo ($pred = FALSE): SELECT * FROM bar WHERE $pred;', kind: _ParseKind.driftFile); }); test('nested star', () { testFormat('q: SELECT foo.** FROM foo;', kind: _ParseKind.driftFile); }); test('transaction block', () { testFormat( ''' test: BEGIN TRANSACTION SELECT * FROM foo; UPDATE foo SET bar = baz; DELETE FROM x; INSERT INTO foo VALUES (x, y, z); COMMIT TRANSACTION; ''', kind: _ParseKind.driftFile, ); }); }); test('does not format invalid statements', () { expect(InvalidStatement().toSql, throwsUnsupportedError); }); } test/utils/ast_quality_test.dart 644 0 0 2764 14152134160 15261 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/utils/ast_equality.dart'; import 'package:test/expect.dart'; import 'package:test/scaffolding.dart'; void main() { group(enforceEqualIterable, () { test('should accept 2 equal iterables', () { enforceEqualIterable( [ NotNull('foo'), ], [ NotNull('foo'), ], ); }); test('should throw if only first is empty', () { expect( () => enforceEqualIterable( [], [ NotNull('foo'), ], ), throwsA(isA()), ); }); test('should throw if only second is empty', () { expect( () => enforceEqualIterable( [ NotNull('foo'), ], [], ), throwsA(isA()), ); }); test('should throw if first is shorter', () { expect( () => enforceEqualIterable( [ NotNull('foo'), ], [ NotNull('foo'), UniqueColumn('foo', null), ], ), throwsA(isA()), ); }); test('should throw if second is shorter', () { expect( () => enforceEqualIterable( [ NotNull('foo'), UniqueColumn('foo', null), ], [ NotNull('foo'), ], ), throwsA(isA()), ); }); }); } test/utils/find_referenced_tables_test.dart 644 0 0 5414 14000111271 17337 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/utils/find_referenced_tables.dart'; import 'package:test/test.dart'; void main() { late SqlEngine engine; const schemaReader = SchemaFromCreateTable(); late Table users, logins; late View oldUsers; setUpAll(() { engine = SqlEngine(); Table addTableFromStmt(String create) { final parsed = engine.parse(create); final table = schemaReader.read(parsed.rootNode as CreateTableStatement); engine.registerTable(table); return table; } View addViewFromStmt(String create) { final result = engine.analyze(create); final view = schemaReader.readView(result, result.root as CreateViewStatement); engine.registerView(view); return view; } users = addTableFromStmt(''' CREATE TABLE users ( id INTEGER NOT NULL PRIMARY KEY, name TEXT NOT NULL, ); '''); logins = addTableFromStmt(''' CREATE TABLE logins ( user INTEGER NOT NULL REFERENCES users (id), timestamp INT ); '''); oldUsers = addViewFromStmt(''' CREATE VIEW old_users AS SELECT u.* FROM users u WHERE (SELECT MAX(timestamp) FROM logins WHERE user = u.id) < 10000; '''); }); test('recognizes read tables', () { final ctx = engine.analyze('SELECT * FROM logins INNER JOIN users u ' 'ON u.id = logins.user;'); expect(findReferencedTables(ctx.root), {users, logins}); }); test('finds views', () { final ctx = engine.analyze('SELECT * FROM old_users WHERE id > 10'); final visitor = ReferencedTablesVisitor()..visit(ctx.root, null); expect(visitor.foundViews, {oldUsers}); }); test('resolves aliased tables', () { final ctx = engine.analyze(''' CREATE TRIGGER foo AFTER INSERT ON users BEGIN INSERT INTO logins (user, timestamp) VALUES (new.id, 0); END; '''); final body = (ctx.root as CreateTriggerStatement).action; // Users referenced via "new" in body. expect(findReferencedTables(body), contains(users)); }); group('recognizes written tables', () { test('for insert', () { final ctx = engine.analyze('INSERT INTO logins ' 'SELECT id, CURRENT_TIME FROM users;'); expect( findWrittenTables(ctx.root), {TableWrite(logins, UpdateKind.insert)}); }); test('for deletes', () { final ctx = engine.analyze('DELETE FROM users;'); expect( findWrittenTables(ctx.root), {TableWrite(users, UpdateKind.delete)}); }); }); test('ignores unresolved references', () { final ctx = engine.analyze('UPDATE xzy SET foo = bar'); expect(findWrittenTables(ctx.root), isEmpty); expect(ctx.errors, hasLength(3)); // unknown table, two unknown references }); } test/engine/autocomplete/static_test.dart 644 0 0 2261 13764474313 17026 0ustar0 pubpubimport 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; import 'utils.dart'; void main() { test('suggests a CREATE an empty file', () { final suggestions = completionsFor('^'); expect(suggestions.anchor, 0); expect(suggestions, suggests('CREATE')); }); test('suggests CREATE TABLE completion after CREATE', () async { final suggestions = completionsFor('CREATE ^'); expect(suggestions.anchor, 7); expect(suggestions, suggests('TABLE')); }); test('suggests completions for started keywords', () { final suggestions = completionsFor('creat^'); expect(suggestions.anchor, 0); expect(suggestions, suggests('CREATE')); }); } dynamic hasCode(dynamic code) => SuggestionWithCode(code); class SuggestionWithCode extends Matcher { final Matcher codeMatcher; SuggestionWithCode(dynamic code) : codeMatcher = wrapMatcher(code); @override Description describe(Description description) { return description.add('suggests ').addDescriptionOf(codeMatcher); } @override bool matches(dynamic item, Map matchState) { return item is Suggestion && codeMatcher.matches(item.code, matchState); } } test/engine/autocomplete/utils.dart 644 0 0 3126 14206506651 15632 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; /// Parses the [driftFile] and computes available autocomplete suggestions at /// the position of a `^` character in the source. ComputedSuggestions completionsFor(String driftFile, {void Function(SqlEngine)? setup}) { final position = driftFile.indexOf('^'); final engine = SqlEngine(EngineOptions(useDriftExtensions: true)); setup?.call(engine); final result = engine.parseDriftFile(driftFile.replaceFirst('^', '')); return result.autoCompleteEngine!.suggestCompletions(position - 1); } Matcher hasCode(String code) => _SuggestionWithCode(code); Matcher suggests(String code) => _SuggestsMatcher(contains(hasCode(code))); Matcher suggestsAll(List codes) { return _SuggestsMatcher(containsAll(codes.map(hasCode))); } class _SuggestionWithCode extends Matcher { final Matcher codeMatcher; _SuggestionWithCode(dynamic code) : codeMatcher = wrapMatcher(code); @override Description describe(Description description) { return description.add('suggests ').addDescriptionOf(codeMatcher); } @override bool matches(dynamic item, Map matchState) { return item is Suggestion && codeMatcher.matches(item.code, matchState); } } class _SuggestsMatcher extends CustomMatcher { _SuggestsMatcher(matcher) : super('Suggestions containing', 'suggestions', matcher); @override List? featureValueOf(dynamic actual) { if (actual is ComputedSuggestions) { return actual.suggestions; } return null; } } test/engine/autocomplete/table_name_test.dart 644 0 0 2410 14206506626 17615 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:sqlparser/src/engine/autocomplete/engine.dart'; import 'package:test/test.dart'; import '../../analysis/data.dart'; import 'utils.dart'; void main() { group('suggests table name', () { test('after SELECT FROM', () { expect(_compute('a: SELECT * FROM ^'), suggestsTables); }); test('in join', () { expect(_compute('a: SELECT * FROM demo INNER JOIN ^;'), suggestsTables); }); test('after update', () { expect(_compute('a: UPDATE ^ SET'), suggestsTables); }); test('after insert', () { expect(_compute('a: INSERT INTO ^;'), suggestsTables); }); test('in index', () { final suggestion = _compute('CREATE INDEX IF NOT EXISTS name ON ^ (id)'); expect(suggestion, suggestsTables); }); test('in trigger', () { final suggestion = _compute('CREATE TRIGGER name BEFORE DELETE ON ^'); expect(suggestion, suggestsTables); }); }); } ComputedSuggestions _compute(String driftFile) { return completionsFor(driftFile, setup: _setupEngine); } void _setupEngine(SqlEngine engine) { engine ..registerTable(demoTable) ..registerTable(anotherTable); } Matcher get suggestsTables => suggestsAll(['demo', 'tbl', 'sqlite_master']); test/engine/options.dart 644 0 0 654 14025064205 13440 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('refuses to work with old sqlite versions', () { expect(() => EngineOptions(version: const SqliteVersion.v3(12)), throwsArgumentError); }); test('refuses to work with unsupported new sqlite versions', () { expect(() => EngineOptions(version: const SqliteVersion.v3(99)), throwsArgumentError); }); } test/engine/sql_engine_test.dart 644 0 0 1344 14000111271 15132 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('does not throw when parsing invalid statements', () { final engine = SqlEngine(); late ParseResult result; try { result = engine.parse('UDPATE foo SET bar = foo;'); } on ParsingError { fail('Calling engine.parse threw an error'); } expect(result.errors, isNotEmpty); }); test('does not throw when analyzing invalid statements', () { final engine = SqlEngine(); late AnalysisContext result; try { result = engine.analyze('UDPATE foo SET bar = foo;'); } on ParsingError { fail('Calling engine.parse threw an error'); } expect(result.errors, isNotEmpty); }); } test/engine/module/json1_test.dart 644 0 0 4561 14000111271 15331 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { group('json with new type inference', () { final engine = SqlEngine(EngineOptions( enabledExtensions: const [Json1Extension()], )); // add user (name, phone) table final table = engine.schemaReader.read( engine.parse('CREATE TABLE user (name TEXT, phone TEXT)').rootNode as TableInducingStatement, ); engine.registerTable(table); ResolveResult findResult(String expression) { final result = engine.analyze('SELECT $expression;'); final select = result.root as SelectStatement; final column = select.resultSet.resolvedColumns!.single; return result.typeOf(column); } const resolvedString = ResolveResult(ResolvedType(type: BasicType.text)); test('create json', () { expect(findResult("json('{}')"), resolvedString); expect(findResult("json_array('foo', 'bar')"), resolvedString); expect(findResult("json_insert('{}')"), resolvedString); expect(findResult("json_replace('{}')"), resolvedString); expect(findResult("json_set('{}')"), resolvedString); expect(findResult('json_object()'), resolvedString); expect(findResult("json_patch('{}', '{}')"), resolvedString); expect(findResult("json_remove('{}', '{}')"), resolvedString); expect(findResult("json_quote('foo')"), resolvedString); expect(findResult('json_group_array()'), resolvedString); expect(findResult('json_group_object()'), resolvedString); }); test('json_type', () { expect( findResult("json_type('foo', 'bar')"), const ResolveResult(ResolvedType(type: BasicType.text, nullable: true)), ); }); test('json_valid', () { expect( findResult('json_valid()'), const ResolveResult(ResolvedType.bool())); }); test('json_extract', () { expect(findResult('json_extract()'), const ResolveResult.unknown()); }); test('json_array_length', () { expect( findResult('json_array_length()'), const ResolveResult(ResolvedType(type: BasicType.int)), ); }); test('can use table-valued functions', () { final result = engine.analyze(''' SELECT DISTINCT user.name FROM user, json_each(user.phone) WHERE json_each.value LIKE '704-%'; '''); expect(result.errors, isEmpty); }); }); } test/engine/module/math_test.dart 644 0 0 4012 14025064205 15232 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { final engine = SqlEngine(EngineOptions( version: SqliteVersion.current, enabledExtensions: const [BuiltInMathExtension()], )); ResolveResult resolveExpr(String expr) { final result = engine.analyze('SELECT $expr;'); final column = ((result.root as SelectStatement).columns.single as ExpressionResultColumn) .expression; return result.typeOf(column); } test('refuses to work with old sqlite versions', () { expect( () => SqlEngine(EngineOptions( enabledExtensions: const [BuiltInMathExtension()], )), throwsStateError, ); }); test('reports pi as double', () { expect(resolveExpr('pi()').type?.type, BasicType.real); }); test('reports sin as double', () { expect(resolveExpr('sin(3)').type?.type, BasicType.real); }); test('reports ceil as int', () { expect(resolveExpr('ceil(3.5)').type?.type, BasicType.int); }); test('infers arguments as numeric', () { final result = engine.analyze('SELECT sin(?);'); final variable = result.root.allDescendants.whereType().first; expect(result.typeOf(variable).type?.type, BasicType.real); }); group('checks amount of arguments', () { test('for log', () { expect(engine.analyze('SELECT log(2)').errors, isEmpty); expect(engine.analyze('SELECT log(2, 4)').errors, isEmpty); expect(engine.analyze('SELECT log(2, 4, 8)').errors, isNotEmpty); }); test('for pi', () { expect(engine.analyze('SELECT pi()').errors, isEmpty); expect(engine.analyze('SELECT pi(3)').errors, isNotEmpty); }); test('for radians', () { expect(engine.analyze('SELECT radians(3)').errors, isEmpty); expect(engine.analyze('SELECT radians(3, 4)').errors, isNotEmpty); }); test('for power', () { expect(engine.analyze('SELECT power(3, 4)').errors, isEmpty); expect(engine.analyze('SELECT power(3)').errors, isNotEmpty); }); }); } test/engine/module/fts5_test.dart 644 0 0 14362 14131303604 15210 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; final _fts5Options = EngineOptions(enabledExtensions: const [Fts5Extension()]); void main() { group('creating fts5 tables', () { final engine = SqlEngine(_fts5Options); test('can create fts5 tables', () { final result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' "fts5(bar , tokenize = 'porter ascii')"); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); final columns = table.resultColumns; expect(columns, hasLength(1)); expect(columns.single.name, 'bar'); }); test('handles the UNINDEXED column option', () { final result = engine .analyze('CREATE VIRTUAL TABLE foo USING fts5(bar, baz UNINDEXED)'); final table = const SchemaFromCreateTable() .read(result.root as TableInducingStatement); expect(table.name, 'foo'); expect(table.resultColumns.map((c) => c.name), ['bar', 'baz']); }); }); group('type inference for function calls', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); test('return type of bm25()', () { final result = engine .analyze('SELECT *, bm25(foo) AS b FROM foo WHERE foo MATCH \'\''); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.real))); }); test('return type of highlight()', () { final result = engine.analyze("SELECT *, highlight(foo, 0, '', '') AS b " "FROM foo WHERE foo MATCH ''"); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.text))); }); test('return type of snippet()', () { final result = engine .analyze("SELECT *, snippet(foo, 0, '', '', '...', 20) AS b " "FROM foo WHERE foo MATCH ''"); expect(result.errors, isEmpty); final select = result.root as SelectStatement; final column = select.resolvedColumns!.singleWhere((c) => c.name == 'b'); expect(result.typeOf(column), const ResolveResult(ResolvedType(type: BasicType.text))); }); }); group('type inference for function arguments', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE fts USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); }); void checkVarTypes(String sql, List expected) { final result = engine.analyze(sql); expect(result.errors, isEmpty); final foundVars = result.root.allDescendants.whereType(); expect( foundVars.map((Typeable t) => result.typeOf(t).type!.type), expected, ); } test('for highlight()', () { checkVarTypes( 'SELECT highlight(fts, ?, ?, ?) FROM fts;', [ BasicType.int, // column index BasicType.text, // text before phrase match BasicType.text, // text after phrase match ], ); }); test('for snippet()', () { checkVarTypes( 'SELECT snippet(fts, ?, ?, ?, ?, ?) FROM fts;', [ BasicType.int, // column index BasicType.text, // text before match BasicType.text, // text after match BasicType.text, // text to add match isn't at start BasicType.int, // maximum number of tokens ], ); }); }); group('error reporting', () { late SqlEngine engine; setUp(() { engine = SqlEngine(_fts5Options); // add an fts5 table for the following queries final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); final normalResult = engine.analyze('CREATE TABLE other (bar TEXT);'); engine.registerTable(const SchemaFromCreateTable() .read(normalResult.root as TableInducingStatement)); }); Matcher hasMessage(Object msgMatcher) { return const TypeMatcher() .having((e) => e.message, 'message', msgMatcher); } test('when using star function parameters', () { final result = engine.analyze('SELECT bm25(*) FROM foo;'); expect(result.errors, [hasMessage(contains('star parameter'))]); }); test('when using a non-fts5 table as parameter', () { final result = engine.analyze('SELECT bm25(bar) FROM other'); expect(result.errors, [hasMessage(contains('fts5 table name'))]); }); test('when using the wrong number or arguments', () { final result = engine.analyze('SELECT highlight(foo, 3) FROM foo'); expect( result.errors, [ hasMessage(stringContainsInOrder(['highlight', '4', '2'])) ], ); }); }); test('does not include rank and table columns in result', () { final engine = SqlEngine(_fts5Options); final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING ' 'fts5(bar, baz);'); engine.registerTable(const SchemaFromCreateTable() .read(fts5Result.root as TableInducingStatement)); final selectResult = engine.analyze('SELECT * FROM foo;'); final columns = (selectResult.root as SelectStatement).resolvedColumns; expect(columns, isNot(anyElement((Column c) => c.name == 'rank'))); expect(columns, isNot(anyElement((Column c) => c.name == 'foo'))); }); } test/engine/find_node_by_position_test.dart 644 0 0 1331 13764474313 17376 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; import 'package:test/test.dart'; void main() { test('finds the most relevant node', () { final engine = SqlEngine(); final result = engine.parse('SELECT * FROM tbl;'); // | this is offset 8 // | this is offset 17 final mostRelevantAtStar = result.findNodesAtPosition(8); expect(mostRelevantAtStar.length, 1); expect(mostRelevantAtStar.single, const TypeMatcher()); final mostRelevantAtTbl = result.findNodesAtPosition(17, length: 2); expect(mostRelevantAtTbl.length, 1); expect(mostRelevantAtTbl.single, const TypeMatcher()); }); } example/sqlparser_example.dart 644 0 0 3620 14151750563 14730 0ustar0 pubpubimport 'package:sqlparser/sqlparser.dart'; // Example that parses a select statement on some tables defined below and // prints what columns would be returned by that statement. void main() { final engine = SqlEngine() ..registerTableFromSql( ''' CREATE TABLE frameworks ( id INTEGER NOT NULL PRIMARY KEY, name TEXT NOT NULL, popularity REAL NOT NULL ); ''', ) ..registerTableFromSql( ''' CREATE TABLE languages ( id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL ); ''', ) ..registerTableFromSql( ''' CREATE TABLE uses_language ( framework INTEGER NOT NULL REFERENCES frameworks (id), language INTEGER NOT NULL REFERENCES languages (id), PRIMARY KEY (framework, language) ); ''', ); // Use SqlEngine.analyze to parse a single sql statement and analyze it. // Analysis can be used to find semantic errors, lints and inferred types of // expressions or result columns. final result = engine.analyze(''' SELECT f.* FROM frameworks f INNER JOIN uses_language ul ON ul.framework = f.id INNER JOIN languages l ON l.id = ul.language WHERE l.name = 'Dart' ORDER BY f.name ASC, f.popularity DESC LIMIT 5 OFFSET 5 * 3 '''); result.errors.forEach(print); final select = result.root as SelectStatement; final columns = select.resolvedColumns!; print('the query returns ${columns.length} columns'); for (final column in columns) { final type = result.typeOf(column); print('${column.name}, which will be a $type'); } } extension on SqlEngine { /// Utility function that parses a `CREATE TABLE` statement and registers the /// created table to the engine. void registerTableFromSql(String createTable) { final stmt = parse(createTable).rootNode as CreateTableStatement; registerTable(schemaReader.read(stmt)); } } mono_pkg.yaml 644 0 0 223 13527467305 11350 0ustar0 pubpubdart: - stable stages: - analyze: - dartanalyzer: --fatal-infos --fatal-warnings lib/ test/ - dartfmt - unit_test: - test CHANGELOG.md 644 0 0 15532 14206507646 10533 0ustar0 pubpub## 0.21.0 - Analysis support for new features in sqlite version 3.38. - Replace internal `moor` references with `drift` references. ## 0.20.1 - Fix SQL generation for upsert statements with a conflict target. ## 0.20.0 - Support `LIST` columns for a drift-specific feature. ## 0.19.2 - Improve handling of drift-specific column types in `STRICT` tables. ## 0.19.1 - Make the result of `group_concat` nullable. ## 0.19.0 - Support generated columns. - Support features introduced in sqlite version 3.37, most notably `STRICT` tables. ## 0.18.1 - Fix the AST comparator missing errors for different amount of children. ## 0.18.0 - Fix unecessary errors around `fts5` tables - Merge all moor-specific nodes into a single `visitMoorSpecific` visitor method - Parse `BEGIN` and `COMMIT` statements - Improve type inference around `RETURNING` clauses. ## 0.17.2 - Fix nullability analysis of `COALESCE` and `IFNULL` ## 0.17.1 - Fix nullability analysis of references and star columns ## 0.17.0 - Refactor how tables and columns are resolved in statements - The new `ResultSetAvailableInStatement` class describes a result set that has been added to a statement, for instance through a from clause - A `TableOrSubquery` with an alias now introduces a `TableAlias` instead of the original table ## 0.16.0 - New analysis checks for `RETURNING`: Disallow `table.*` syntax and aggregate expressions - Support `RAISE` expressions in triggers - Fix resolving columns when `RETURNING` is used in an `UPDATE FROM` statement - Fix aliases to rowid being reported as nullable ## 0.15.0 - __Breaking__: Change `InsertStatement.upsert` to a list of upsert clauses - Support multiple upsert clauses - Do not require a conflict target in the last clause - Support `RETURNING` clauses in updates, deletes and inserts - Support `FROM` clauses in `UPDATE` statements - Support `MATERIALIZED`/`NOT MATERIALIZED` hints in common table expressions - Add `BuiltInMathExtension` which corresponds to the `-DSQLITE_ENABLE_MATH_FUNCTIONS` compile-time option for sqlite. - Add `EngineOptions.version` argument to specify the desired sqlite version. Using newer features will be reported as analysis warnings. - Fix `rank` columns of fts5 tables being misreported as integers ## 0.14.0 - Fix views using common table expressions ## 0.13.0-nullsafety.0 - Parse ordering in table key constraints - Deprecate `KeyClause.indexedColumns` in favor of `KeyClause.columns` ## 0.12.0-nullsafety.0 - Migrate to null-safety - Remove legacy type inference - Parser support for new moor features ## 0.11.0 - New `package:sqlparser/utils/node_to_text.dart` library that turns an AST node back into a textual representation. - Fix precedence of `CASE` expressions ## 0.10.1 - Scan identifiers with `[bracket syntax]` - `NumericToken` now contains individual lexemes making up the number - Improve error messages in some scenarios - Fix type inference for binary expressions where the operands have incompatible types - Improve type inference around `NULL` ## 0.10.0 - Breaking: Made `RecursiveVisitor.visit`, `visitList` and `visitExcept` an extension on `AstVisitor`. - Support the transformer pattern to modify ast nodes - Breaking: `FrameBoundary`, `DeleteTarget`, `UpdateTarget`, `DefaultValues` and `InsertTarget` are no longer constant - Breaking: Removed `visitQueryable`. Use `defaultQueryable` instead. - Support parsing and analyzing `CREATE VIEW` statements (see `SchemaFromCreateTable.readView`). Thanks to [@mqus](https://github.com/mqus) for their contribution! - `SqlEngine.parse` will no longer throw when there's a parsing error (use `ParseResult.errors` instead). - Parse `DEFERRABLE` clauses on foreign key constraints - Parse `NULLS FIRST` and `NULLS LAST` on `ORDER BY` terms ## 0.9.0 - New `package:sqlparser/utils/find_referenced_tables.dart` library. Use it to easily find all referenced tables in a query. - Support [row values](https://www.sqlite.org/rowvalue.html) including warnings about misuse ## 0.8.1 - Support collate expressions in the new type inference ([#533](htt ps://github.com/simolus3/moor/issues/533)) - Added `visitCollateExpression` to the visitor classes ## 0.8.0 - Remove `SqlEngine.withOptions` constructor - the default constructor now takes options - Changed `SelectStatement.from` from `List` to `Queryable?`. Selecting from multiple tables with a comma will now be parsed as a `JoinClause`. - Changed `SelectStatementAsSource.statement` from `SelectStatement` to `BaseSelectStatement` and allow compound select statements to appear in a `FROM` clause - Support the `VALUES` clause as select statement - The new type inference engine is now enabled by default and the `enableExperimentalTypeInference` option has been removed. To continue using the old engine, the `useLegacyTypeInference` flag can be used. ## 0.7.0 - New feature: Table valued functions. - __Breaking__: Removed the `enableJson1` parameter on `EngineOptions`. Add a `Json1Extension` instance to `enabledExtensions` instead. - Parse `rowid` as a valid reference when needed (`SELECT rowid FROM tbl` is now parsed correctly) - Parse `CURRENT_TIME`, `CURRENT_DATE` and `CURRENT_TIMESTAMP` - Parse `UPSERT` clauses for insert statements ## 0.6.0 - __Breaking:__ Added an argument type and argument to the visitor classes - Experimental new type inference algorithm (`SqlEngine.withOptions(EngineOptions(enableExperimentalTypeInference: true))`) - Support `CAST` expressions and the `ISNULL` / `NOTNULL` postfixes - Support parsing `CREATE TRIGGER` statements - Support parsing `CREATE INDEX` statements ## 0.5.0 - Optionally support the `json1` module - Optionally support the `fts5` module ## 0.4.0 - Support common table expressions - Handle special `rowid`, `oid`, `__rowid__` references - Support references to `sqlite_master` and `sqlite_sequence` tables ## 0.3.0 - parse compound select statements - scan comment tokens - experimental auto-complete engine (only supports a tiny subset based on the grammar only) - some features that are specific to moor __0.3.0+1__: Accept `\r` characters as whitespace ## 0.2.0 - Parse `CREATE TABLE` statements - Extract schema information from parsed create table statements with `SchemaFromCreateTable`. ## 0.1.2 - parse `COLLATE` expressions - fix wrong order in parsed `LIMIT` clauses ## 0.1.1 Attempt to recognize when a bound variable should be an array (eg. in `WHERE x IN ?`). Also fixes a number of parsing bugs: - Parses tuples, proper type resolution for `IN` expressions - Don't resolve references to tables that don't appear in the surrounding statement. - Parse joins without any additional operator, e.g. `table1 JOIN table2` instead of `table1 CROSS JOIN table2`. - Parser now complains when parsing a query doesn't fully consume the input ## 0.1.0 Initial version, can parse most statements but not `DELETE`, common table expressions and other advanced features.pubspec.yaml 644 0 0 745 14213402572 11175 0ustar0 pubpubname: sqlparser description: Parses sqlite statements and performs static analysis on them version: 0.21.0 homepage: https://github.com/simolus3/drift/tree/develop/sqlparser #homepage: https://drift.simonbinder.eu/ issue_tracker: https://github.com/simolus3/drift/issues environment: sdk: '>=2.12.0 <3.0.0' dependencies: meta: ^1.3.0 collection: ^1.15.0 source_span: ^1.8.0 charcode: ^1.2.0 dev_dependencies: test: ^1.17.4 path: ^1.8.0 ffi: ^1.0.0 sqlite3: ^1.0.0 README.md 644 0 0 6077 14206507551 10160 0ustar0 pubpub# sqlparser Sql parser and static analyzer written in Dart. At the moment, this library targets the sqlite dialect only. ## Features This library aims to support every sqlite feature, which includes parsing and detailed static analysis. We can resolve what type a column in a `SELECT` statement has, infer types for variables, find semantic errors and more. This library supports most sqlite features: - DQL: Full support, including joins, `group by`, nested and compound selects, `WITH` clauses and window functions - DDL: Supports `CREATE TABLE` statements, including advanced features like foreign keys or virtual tables (when a matching module like `fts5` is enabled). This library also supports `CREATE TRIGGER` and `CREATE INDEX` statements. ### Using the parser To obtain an abstract syntax tree from an sql statement, use `SqlEngine.parse`. ```dart import 'package:sqlparser/sqlparser.dart'; final engine = SqlEngine(); final result = engine.parse(''' SELECT f.* FROM frameworks f INNER JOIN uses_language ul ON ul.framework = f.id INNER JOIN languages l ON l.id = ul.language WHERE l.name = 'Dart' ORDER BY f.name ASC, f.popularity DESC LIMIT 5 OFFSET 5 * 3 '''); // result.rootNode contains the select statement in tree form ``` ### Analysis Given information about all tables and 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? [Drift](https://pub.dev/packages/drift), a persistence library for Dart apps, uses this package to generate type-safe methods from sql. ## Thanks - To [Bob Nystrom](https://github.com/munificent) for his amazing ["Crafting Interpreters"](https://craftinginterpreters.com/) book, which was incredibly helpful when writing the parser.