mirror of https://github.com/AMT-Cheif/drift.git
Add code generation for nested result queries
This commit is contained in:
Daniel Brauner
parent
ca8482be71
commit
23de4c5cee
|
|
@ -1,6 +1,8 @@
|
|||
// Mega compilation unit that includes all Dart apis related to generating SQL
|
||||
// at runtime.
|
||||
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:collection/collection.dart';
|
||||
import 'package:drift/drift.dart';
|
||||
import 'package:drift/sqlite_keywords.dart';
|
||||
|
|
|
|||
|
|
@ -250,28 +250,29 @@ abstract class Selectable<T>
|
|||
///
|
||||
/// Each entry emitted by this [Selectable] will be transformed by the
|
||||
/// [mapper] and then emitted to the selectable returned.
|
||||
Selectable<N> map<N>(N Function(T) mapper) {
|
||||
Selectable<N> map<N>(FutureOr<N> Function(T) mapper) {
|
||||
return _MappedSelectable<T, N>(this, mapper);
|
||||
}
|
||||
}
|
||||
|
||||
class _MappedSelectable<S, T> extends Selectable<T> {
|
||||
final Selectable<S> _source;
|
||||
final T Function(S) _mapper;
|
||||
final FutureOr<T> Function(S) _mapper;
|
||||
|
||||
_MappedSelectable(this._source, this._mapper);
|
||||
|
||||
@override
|
||||
Future<List<T>> get() {
|
||||
Future<List<T>> get() async {
|
||||
return _source.get().then(_mapResults);
|
||||
}
|
||||
|
||||
@override
|
||||
Stream<List<T>> watch() {
|
||||
return _source.watch().map(_mapResults);
|
||||
return _source.watch().asyncMap(_mapResults);
|
||||
}
|
||||
|
||||
List<T> _mapResults(List<S> results) => results.map(_mapper).toList();
|
||||
Future<List<T>> _mapResults(List<S> results) async =>
|
||||
[for (final result in results) await _mapper(result)];
|
||||
}
|
||||
|
||||
/// Mixin for a [Query] that operates on a single primary table only.
|
||||
|
|
|
|||
|
|
@ -167,8 +167,8 @@ class SqlAnalyzer extends BaseAnalyzer {
|
|||
|
||||
try {
|
||||
final handled =
|
||||
QueryHandler(query, context, mapper, requiredVariables: variables)
|
||||
.handle()
|
||||
QueryHandler(context, mapper, requiredVariables: variables)
|
||||
.handle(query)
|
||||
..declaredInMoorFile = query is DeclaredMoorQuery;
|
||||
foundQueries.add(handled);
|
||||
} catch (e, s) {
|
||||
|
|
|
|||
|
|
@ -11,7 +11,6 @@ import 'required_variables.dart';
|
|||
/// generator package by determining its type, return columns, variables and so
|
||||
/// on.
|
||||
class QueryHandler {
|
||||
final DeclaredQuery source;
|
||||
final AnalysisContext context;
|
||||
final TypeMapper mapper;
|
||||
final RequiredVariables requiredVariables;
|
||||
|
|
@ -23,19 +22,30 @@ class QueryHandler {
|
|||
Iterable<FoundVariable> get _foundVariables =>
|
||||
_foundElements.whereType<FoundVariable>();
|
||||
|
||||
BaseSelectStatement get _select => context.root as BaseSelectStatement;
|
||||
QueryHandler(
|
||||
this.context,
|
||||
this.mapper, {
|
||||
this.requiredVariables = RequiredVariables.empty,
|
||||
});
|
||||
|
||||
QueryHandler(this.source, this.context, this.mapper,
|
||||
{this.requiredVariables = RequiredVariables.empty});
|
||||
|
||||
String get name => source.name;
|
||||
|
||||
SqlQuery handle() {
|
||||
SqlQuery handle(DeclaredQuery source) {
|
||||
_foundElements =
|
||||
mapper.extractElements(context, required: requiredVariables);
|
||||
|
||||
_verifyNoSkippedIndexes();
|
||||
final query = _mapToMoor();
|
||||
|
||||
final String? requestedResultClass;
|
||||
if (source is DeclaredMoorQuery) {
|
||||
requestedResultClass = source.astNode.as;
|
||||
} else {
|
||||
requestedResultClass = null;
|
||||
}
|
||||
|
||||
final query = _mapToMoor(
|
||||
queryName: source.name,
|
||||
requestedResultClass: requestedResultClass,
|
||||
root: context.root,
|
||||
);
|
||||
|
||||
final linter = Linter.forHandler(this);
|
||||
linter.reportLints();
|
||||
|
|
@ -44,14 +54,21 @@ class QueryHandler {
|
|||
return query;
|
||||
}
|
||||
|
||||
SqlQuery _mapToMoor() {
|
||||
final root = context.root;
|
||||
SqlQuery _mapToMoor({
|
||||
required String queryName,
|
||||
required String? requestedResultClass,
|
||||
required AstNode root,
|
||||
}) {
|
||||
if (root is BaseSelectStatement) {
|
||||
return _handleSelect();
|
||||
return _handleSelect(
|
||||
queryName: queryName,
|
||||
requestedResultClass: requestedResultClass,
|
||||
select: root,
|
||||
);
|
||||
} else if (root is UpdateStatement ||
|
||||
root is DeleteStatement ||
|
||||
root is InsertStatement) {
|
||||
return _handleUpdate();
|
||||
return _handleUpdate(queryName, root);
|
||||
} else {
|
||||
throw StateError('Unexpected sql: Got $root, expected insert, select, '
|
||||
'update or delete');
|
||||
|
|
@ -63,25 +80,25 @@ class QueryHandler {
|
|||
_foundViews = visitor.foundViews;
|
||||
}
|
||||
|
||||
UpdatingQuery _handleUpdate() {
|
||||
UpdatingQuery _handleUpdate(String queryName, AstNode root) {
|
||||
final updatedFinder = UpdatedTablesVisitor();
|
||||
context.root.acceptWithoutArg(updatedFinder);
|
||||
root.acceptWithoutArg(updatedFinder);
|
||||
_applyFoundTables(updatedFinder);
|
||||
|
||||
final root = context.root;
|
||||
final isInsert = root is InsertStatement;
|
||||
|
||||
InferredResultSet? resultSet;
|
||||
if (root is StatementReturningColumns) {
|
||||
final columns = root.returnedResultSet?.resolvedColumns;
|
||||
if (columns != null) {
|
||||
resultSet = _inferResultSet(columns);
|
||||
resultSet = _inferResultSet(root, columns);
|
||||
}
|
||||
}
|
||||
|
||||
return UpdatingQuery(
|
||||
name,
|
||||
queryName,
|
||||
context,
|
||||
root,
|
||||
_foundElements,
|
||||
updatedFinder.writtenTables
|
||||
.map(mapper.writtenToMoor)
|
||||
|
|
@ -93,9 +110,14 @@ class QueryHandler {
|
|||
);
|
||||
}
|
||||
|
||||
SqlSelectQuery _handleSelect() {
|
||||
SqlSelectQuery _handleSelect({
|
||||
required String queryName,
|
||||
required String? requestedResultClass,
|
||||
required BaseSelectStatement select,
|
||||
}) {
|
||||
final tableFinder = ReferencedTablesVisitor();
|
||||
_select.acceptWithoutArg(tableFinder);
|
||||
select.acceptWithoutArg(tableFinder);
|
||||
// fine
|
||||
_applyFoundTables(tableFinder);
|
||||
|
||||
final moorTables =
|
||||
|
|
@ -105,22 +127,18 @@ class QueryHandler {
|
|||
|
||||
final moorEntities = [...moorTables, ...moorViews];
|
||||
|
||||
String? requestedName;
|
||||
if (source is DeclaredMoorQuery) {
|
||||
requestedName = (source as DeclaredMoorQuery).astNode.as;
|
||||
}
|
||||
|
||||
return SqlSelectQuery(
|
||||
name,
|
||||
queryName,
|
||||
context,
|
||||
select,
|
||||
_foundElements,
|
||||
moorEntities,
|
||||
_inferResultSet(_select.resolvedColumns!),
|
||||
requestedName,
|
||||
_inferResultSet(select, select.resolvedColumns!),
|
||||
requestedResultClass,
|
||||
);
|
||||
}
|
||||
|
||||
InferredResultSet _inferResultSet(List<Column> rawColumns) {
|
||||
InferredResultSet _inferResultSet(AstNode select, List<Column> rawColumns) {
|
||||
final candidatesForSingleTable = {..._foundTables, ..._foundViews};
|
||||
final columns = <ResultColumn>[];
|
||||
|
||||
|
|
@ -140,7 +158,7 @@ class QueryHandler {
|
|||
candidatesForSingleTable.removeWhere((t) => t != resultSet);
|
||||
}
|
||||
|
||||
final nestedResults = _findNestedResultTables();
|
||||
final nestedResults = _findNestedResultTables(select);
|
||||
if (nestedResults.isNotEmpty) {
|
||||
// The single table optimization doesn't make sense when nested result
|
||||
// sets are present.
|
||||
|
|
@ -202,12 +220,11 @@ class QueryHandler {
|
|||
return InferredResultSet(null, columns, nestedResults: nestedResults);
|
||||
}
|
||||
|
||||
List<NestedResultTable> _findNestedResultTables() {
|
||||
final query = context.root;
|
||||
List<NestedResult> _findNestedResultTables(AstNode query) {
|
||||
// We don't currently support nested results for compound statements
|
||||
if (query is! SelectStatement) return const [];
|
||||
|
||||
final nestedTables = <NestedResultTable>[];
|
||||
final nestedTables = <NestedResult>[];
|
||||
final analysis = JoinModel.of(query);
|
||||
|
||||
for (final column in query.columns) {
|
||||
|
|
@ -225,6 +242,15 @@ class QueryHandler {
|
|||
moorTable,
|
||||
isNullable: isNullable,
|
||||
));
|
||||
} else if (column is NestedQueryColumn) {
|
||||
nestedTables.add(NestedResultQuery(
|
||||
from: column,
|
||||
query: _handleSelect(
|
||||
queryName: 'nested',
|
||||
requestedResultClass: column.as,
|
||||
select: column.select,
|
||||
),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
import 'package:build/build.dart';
|
||||
import 'package:drift_dev/moor_generator.dart';
|
||||
import 'package:drift_dev/src/backends/build/moor_builder.dart';
|
||||
import 'package:drift_dev/src/utils/type_utils.dart';
|
||||
import 'package:drift_dev/writer.dart';
|
||||
|
|
@ -32,9 +31,8 @@ class DaoGenerator extends Generator implements BaseGenerator {
|
|||
'$infoType get $getterName => attachedDatabase.$getterName;\n');
|
||||
}
|
||||
|
||||
for (final query in dao.queries ?? const <SqlQuery>[]) {
|
||||
QueryWriter(query, classScope.child()).write();
|
||||
}
|
||||
dao.queries
|
||||
?.forEach((query) => QueryWriter(classScope.child()).write(query));
|
||||
|
||||
classScope.leaf().write('}');
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@ abstract class SqlQuery {
|
|||
final String name;
|
||||
|
||||
AnalysisContext? get fromContext;
|
||||
AstNode? get root;
|
||||
List<AnalysisError>? lints;
|
||||
|
||||
/// Whether this query was declared in a `.moor` file.
|
||||
|
|
@ -165,6 +166,8 @@ class SqlSelectQuery extends SqlQuery {
|
|||
final InferredResultSet resultSet;
|
||||
@override
|
||||
final AnalysisContext fromContext;
|
||||
@override
|
||||
final AstNode root;
|
||||
|
||||
/// The name of the result class, as requested by the user.
|
||||
// todo: Allow custom result classes for RETURNING as well?
|
||||
|
|
@ -173,6 +176,7 @@ class SqlSelectQuery extends SqlQuery {
|
|||
SqlSelectQuery(
|
||||
String name,
|
||||
this.fromContext,
|
||||
this.root,
|
||||
List<FoundElement> elements,
|
||||
this.readsFrom,
|
||||
this.resultSet,
|
||||
|
|
@ -196,6 +200,7 @@ class SqlSelectQuery extends SqlQuery {
|
|||
return SqlSelectQuery(
|
||||
name,
|
||||
fromContext,
|
||||
root,
|
||||
elements,
|
||||
readsFrom,
|
||||
resultSet,
|
||||
|
|
@ -211,6 +216,8 @@ class UpdatingQuery extends SqlQuery {
|
|||
final InferredResultSet? resultSet;
|
||||
@override
|
||||
final AnalysisContext fromContext;
|
||||
@override
|
||||
final AstNode root;
|
||||
|
||||
bool get isOnlyDelete => updates.every((w) => w.kind == UpdateKind.delete);
|
||||
|
||||
|
|
@ -219,6 +226,7 @@ class UpdatingQuery extends SqlQuery {
|
|||
UpdatingQuery(
|
||||
String name,
|
||||
this.fromContext,
|
||||
this.root,
|
||||
List<FoundElement> elements,
|
||||
this.updates, {
|
||||
this.isInsert = false,
|
||||
|
|
@ -239,6 +247,9 @@ class InTransactionQuery extends SqlQuery {
|
|||
|
||||
@override
|
||||
AnalysisContext? get fromContext => null;
|
||||
|
||||
@override
|
||||
AstNode? get root => null;
|
||||
}
|
||||
|
||||
class InferredResultSet {
|
||||
|
|
@ -249,9 +260,9 @@ class InferredResultSet {
|
|||
|
||||
/// Tables in the result set that should appear as a class.
|
||||
///
|
||||
/// See [NestedResultTable] for further discussion and examples.
|
||||
final List<NestedResultTable> nestedResults;
|
||||
Map<NestedResultTable, String>? _expandedNestedPrefixes;
|
||||
/// See [NestedResult] for further discussion and examples.
|
||||
final List<NestedResult> nestedResults;
|
||||
Map<NestedResult, String>? _expandedNestedPrefixes;
|
||||
|
||||
final List<ResultColumn> columns;
|
||||
final Map<ResultColumn, String> _dartNames = {};
|
||||
|
|
@ -293,7 +304,7 @@ class InferredResultSet {
|
|||
bool get singleColumn =>
|
||||
matchingTable == null && nestedResults.isEmpty && columns.length == 1;
|
||||
|
||||
String? nestedPrefixFor(NestedResultTable table) {
|
||||
String? nestedPrefixFor(NestedResult table) {
|
||||
if (_expandedNestedPrefixes == null) {
|
||||
var index = 0;
|
||||
_expandedNestedPrefixes = {
|
||||
|
|
@ -329,12 +340,17 @@ class InferredResultSet {
|
|||
});
|
||||
}
|
||||
|
||||
/// [hashCode] that matches [isCompatibleTo] instead of `==`.
|
||||
int get compatibilityHashCode => Object.hash(
|
||||
Object.hashAll(columns.map((e) => e.compatibilityHashCode)),
|
||||
Object.hashAll(nestedResults.map((e) => e.compatibilityHashCode)),
|
||||
);
|
||||
|
||||
/// Checks whether this and the [other] result set have the same columns and
|
||||
/// nested result sets.
|
||||
bool isCompatibleTo(InferredResultSet other) {
|
||||
const columnsEquality = UnorderedIterableEquality(_ResultColumnEquality());
|
||||
const nestedEquality =
|
||||
UnorderedIterableEquality(_NestedResultTableEquality());
|
||||
const nestedEquality = UnorderedIterableEquality(_NestedResultEquality());
|
||||
|
||||
return columnsEquality.equals(columns, other.columns) &&
|
||||
nestedEquality.equals(nestedResults, other.nestedResults);
|
||||
|
|
@ -406,6 +422,15 @@ class ResultColumn implements HasType {
|
|||
}
|
||||
}
|
||||
|
||||
/// A nested result, could either be a NestedResultTable or a NestedQueryResult.
|
||||
abstract class NestedResult {
|
||||
/// [hashCode] that matches [isCompatibleTo] instead of `==`.
|
||||
int get compatibilityHashCode;
|
||||
|
||||
/// Checks whether this is compatible to the [other] nested result.
|
||||
bool isCompatibleTo(NestedResult other);
|
||||
}
|
||||
|
||||
/// A nested table extracted from a `**` column.
|
||||
///
|
||||
/// For instance, consider this query:
|
||||
|
|
@ -432,7 +457,7 @@ class ResultColumn implements HasType {
|
|||
///
|
||||
/// Knowing that `User` should be extracted into a field is represented with a
|
||||
/// [NestedResultTable] information as part of the result set.
|
||||
class NestedResultTable {
|
||||
class NestedResultTable extends NestedResult {
|
||||
final bool isNullable;
|
||||
final NestedStarResultColumn from;
|
||||
final String name;
|
||||
|
|
@ -443,19 +468,67 @@ class NestedResultTable {
|
|||
String get dartFieldName => ReCase(name).camelCase;
|
||||
|
||||
/// [hashCode] that matches [isCompatibleTo] instead of `==`.
|
||||
@override
|
||||
int get compatibilityHashCode {
|
||||
return Object.hash(name, table);
|
||||
}
|
||||
|
||||
/// Checks whether this is compatible to the [other] nested result, which is
|
||||
/// the case iff they have the same and read from the same table.
|
||||
bool isCompatibleTo(NestedResultTable other) {
|
||||
@override
|
||||
bool isCompatibleTo(NestedResult other) {
|
||||
if (other is! NestedResultTable) return false;
|
||||
|
||||
return other.name == name &&
|
||||
other.table == table &&
|
||||
other.isNullable == isNullable;
|
||||
}
|
||||
}
|
||||
|
||||
class NestedResultQuery extends NestedResult {
|
||||
final NestedQueryColumn from;
|
||||
|
||||
final SqlSelectQuery query;
|
||||
|
||||
NestedResultQuery({
|
||||
required this.from,
|
||||
required this.query,
|
||||
});
|
||||
|
||||
String filedName(String? nestedPrefix) {
|
||||
if (from.as != null) {
|
||||
return from.as!;
|
||||
}
|
||||
|
||||
final name = ReCase(query.resultClassName).camelCase;
|
||||
|
||||
if (nestedPrefix != null) {
|
||||
return name + nestedPrefix;
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
String resultTypeCode(String parentResultClassName) {
|
||||
if (query.resultSet.needsOwnClass) {
|
||||
return parentResultClassName + query.resultClassName;
|
||||
} else {
|
||||
return query.resultTypeCode();
|
||||
}
|
||||
}
|
||||
|
||||
// Every query should be unique.
|
||||
|
||||
/// [hashCode] that matches [isCompatibleTo] instead of `==`.
|
||||
@override
|
||||
int get compatibilityHashCode => hashCode;
|
||||
|
||||
/// Checks whether this is compatible to the [other] nested result, which is
|
||||
/// the case iff they have the same and read from the same table.
|
||||
@override
|
||||
bool isCompatibleTo(NestedResult other) => this == other;
|
||||
}
|
||||
|
||||
/// Something in the query that needs special attention when generating code,
|
||||
/// such as variables or Dart placeholders.
|
||||
abstract class FoundElement {
|
||||
|
|
@ -742,16 +815,16 @@ class _ResultColumnEquality implements Equality<ResultColumn> {
|
|||
bool isValidKey(Object? e) => e is ResultColumn;
|
||||
}
|
||||
|
||||
class _NestedResultTableEquality implements Equality<NestedResultTable> {
|
||||
const _NestedResultTableEquality();
|
||||
class _NestedResultEquality implements Equality<NestedResult> {
|
||||
const _NestedResultEquality();
|
||||
|
||||
@override
|
||||
bool equals(NestedResultTable e1, NestedResultTable e2) {
|
||||
bool equals(NestedResult e1, NestedResult e2) {
|
||||
return e1.isCompatibleTo(e2);
|
||||
}
|
||||
|
||||
@override
|
||||
int hash(NestedResultTable e) => e.compatibilityHashCode;
|
||||
int hash(NestedResult e) => e.compatibilityHashCode;
|
||||
|
||||
@override
|
||||
bool isValidKey(Object? e) => e is NestedResultTable;
|
||||
|
|
|
|||
|
|
@ -117,9 +117,7 @@ class DatabaseWriter {
|
|||
}
|
||||
|
||||
// Write implementation for query methods
|
||||
for (final query in db.queries ?? const <Never>[]) {
|
||||
QueryWriter(query, dbScope.child()).write();
|
||||
}
|
||||
db.queries?.forEach((query) => QueryWriter(dbScope.child()).write(query));
|
||||
|
||||
// Write List of tables
|
||||
final schemaScope = dbScope.leaf();
|
||||
|
|
|
|||
|
|
@ -18,25 +18,16 @@ int _compareNodes(AstNode a, AstNode b) =>
|
|||
/// Writes the handling code for a query. The code emitted will be a method that
|
||||
/// should be included in a generated database or dao class.
|
||||
class QueryWriter {
|
||||
final SqlQuery query;
|
||||
final Scope scope;
|
||||
|
||||
late ExplicitAliasTransformer _transformer;
|
||||
|
||||
SqlSelectQuery get _select => query as SqlSelectQuery;
|
||||
UpdatingQuery get _update => query as UpdatingQuery;
|
||||
late final ExplicitAliasTransformer _transformer;
|
||||
final StringBuffer _buffer;
|
||||
|
||||
MoorOptions get options => scope.writer.options;
|
||||
late StringBuffer _buffer;
|
||||
|
||||
bool get _newSelectableMode =>
|
||||
query.declaredInMoorFile || options.compactQueryMethods;
|
||||
QueryWriter(this.scope) : _buffer = scope.leaf();
|
||||
|
||||
QueryWriter(this.query, this.scope) {
|
||||
_buffer = scope.leaf();
|
||||
}
|
||||
|
||||
void write() {
|
||||
void write(SqlQuery query) {
|
||||
// Note that writing queries can have a result set if they use a RETURNING
|
||||
// clause.
|
||||
final resultSet = query.resultSet;
|
||||
|
|
@ -54,40 +45,40 @@ class QueryWriter {
|
|||
// analysis, Dart getter names stay the same.
|
||||
if (resultSet != null && options.newSqlCodeGeneration) {
|
||||
_transformer = ExplicitAliasTransformer();
|
||||
_transformer.rewrite(query.fromContext!.root);
|
||||
_transformer.rewrite(query.root!);
|
||||
}
|
||||
|
||||
if (query is SqlSelectQuery) {
|
||||
_writeSelect();
|
||||
_writeSelect(query);
|
||||
} else if (query is UpdatingQuery) {
|
||||
if (resultSet != null) {
|
||||
_writeUpdatingQueryWithReturning();
|
||||
_writeUpdatingQueryWithReturning(query);
|
||||
} else {
|
||||
_writeUpdatingQuery();
|
||||
_writeUpdatingQuery(query);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void _writeSelect() {
|
||||
_writeSelectStatementCreator();
|
||||
void _writeSelect(SqlSelectQuery select) {
|
||||
_writeSelectStatementCreator(select);
|
||||
|
||||
if (!_newSelectableMode) {
|
||||
_writeOneTimeReader();
|
||||
_writeStreamReader();
|
||||
if (!select.declaredInMoorFile && !options.compactQueryMethods) {
|
||||
_writeOneTimeReader(select);
|
||||
_writeStreamReader(select);
|
||||
}
|
||||
}
|
||||
|
||||
String _nameOfCreationMethod() {
|
||||
if (_newSelectableMode) {
|
||||
return query.name;
|
||||
String _nameOfCreationMethod(SqlSelectQuery select) {
|
||||
if (!select.declaredInMoorFile && !options.compactQueryMethods) {
|
||||
return select.name;
|
||||
} else {
|
||||
return '${query.name}Query';
|
||||
return '${select.name}Query';
|
||||
}
|
||||
}
|
||||
|
||||
/// Writes the function literal that turns a "QueryRow" into the desired
|
||||
/// custom return type of a query.
|
||||
void _writeMappingLambda() {
|
||||
void _writeMappingLambda(SqlQuery query) {
|
||||
final resultSet = query.resultSet!;
|
||||
|
||||
if (resultSet.singleColumn) {
|
||||
|
|
@ -119,7 +110,7 @@ class QueryWriter {
|
|||
_buffer.write('})');
|
||||
}
|
||||
} else {
|
||||
_buffer.write('(QueryRow row) { return ${query.resultClassName}(');
|
||||
_buffer.write('(QueryRow row) async { return ${query.resultClassName}(');
|
||||
|
||||
if (options.rawResultSetData) {
|
||||
_buffer.write('row: row,\n');
|
||||
|
|
@ -131,17 +122,35 @@ class QueryWriter {
|
|||
'${readingCode(column, scope.generationOptions, options)},');
|
||||
}
|
||||
for (final nested in resultSet.nestedResults) {
|
||||
final prefix = resultSet.nestedPrefixFor(nested);
|
||||
if (prefix == null) continue;
|
||||
if (nested is NestedResultTable) {
|
||||
final prefix = resultSet.nestedPrefixFor(nested);
|
||||
if (prefix == null) continue;
|
||||
|
||||
final fieldName = nested.dartFieldName;
|
||||
final tableGetter = nested.table.dbGetterName;
|
||||
final fieldName = nested.dartFieldName;
|
||||
final tableGetter = nested.table.dbGetterName;
|
||||
|
||||
final mappingMethod =
|
||||
nested.isNullable ? 'mapFromRowOrNull' : 'mapFromRow';
|
||||
final mappingMethod =
|
||||
nested.isNullable ? 'mapFromRowOrNull' : 'mapFromRow';
|
||||
|
||||
_buffer.write('$fieldName: $tableGetter.$mappingMethod(row, '
|
||||
'tablePrefix: ${asDartLiteral(prefix)}),');
|
||||
_buffer.write('$fieldName: $tableGetter.$mappingMethod(row, '
|
||||
'tablePrefix: ${asDartLiteral(prefix)}),');
|
||||
} else if (nested is NestedResultQuery) {
|
||||
if (!scope.options.newSqlCodeGeneration) {
|
||||
throw UnsupportedError(
|
||||
'To use nested result queries enable new_sql_code_generation',
|
||||
);
|
||||
}
|
||||
|
||||
final prefix = resultSet.nestedPrefixFor(nested);
|
||||
if (prefix == null) continue;
|
||||
|
||||
final fieldName = nested.filedName(prefix);
|
||||
_buffer.write('$fieldName: await ');
|
||||
|
||||
_writeCustomSelectStatement(nested.query);
|
||||
|
||||
_buffer.write('.get()');
|
||||
}
|
||||
}
|
||||
_buffer.write(');\n}');
|
||||
}
|
||||
|
|
@ -180,101 +189,107 @@ class QueryWriter {
|
|||
|
||||
/// Writes a method returning a `Selectable<T>`, where `T` is the return type
|
||||
/// of the custom query.
|
||||
void _writeSelectStatementCreator() {
|
||||
void _writeSelectStatementCreator(SqlSelectQuery select) {
|
||||
final returnType =
|
||||
'Selectable<${_select.resultTypeCode(scope.generationOptions)}>';
|
||||
final methodName = _nameOfCreationMethod();
|
||||
'Selectable<${select.resultTypeCode(scope.generationOptions)}>';
|
||||
final methodName = _nameOfCreationMethod(select);
|
||||
|
||||
_buffer.write('$returnType $methodName(');
|
||||
_writeParameters();
|
||||
_writeParameters(select);
|
||||
_buffer.write(') {\n');
|
||||
|
||||
_writeExpandedDeclarations();
|
||||
_buffer.write('return customSelect(${_queryCode()}, ');
|
||||
_writeVariables();
|
||||
_buffer.write(', ');
|
||||
_writeReadsFrom();
|
||||
|
||||
_buffer.write(').map(');
|
||||
_writeMappingLambda();
|
||||
_buffer.write(');\n}\n');
|
||||
_writeExpandedDeclarations(select);
|
||||
_buffer.write('return');
|
||||
_writeCustomSelectStatement(select);
|
||||
_buffer.write(';\n}\n');
|
||||
}
|
||||
|
||||
void _writeOneTimeReader() {
|
||||
void _writeCustomSelectStatement(SqlSelectQuery select) {
|
||||
_buffer.write(' customSelect(${_queryCode(select)}, ');
|
||||
_writeVariables(select);
|
||||
_buffer.write(', ');
|
||||
_writeReadsFrom(select);
|
||||
|
||||
_buffer.write(').map(');
|
||||
_writeMappingLambda(select);
|
||||
_buffer.write(')');
|
||||
}
|
||||
|
||||
void _writeOneTimeReader(SqlSelectQuery select) {
|
||||
final returnType =
|
||||
'Future<List<${_select.resultTypeCode(scope.generationOptions)}>>';
|
||||
_buffer.write('$returnType ${query.name}(');
|
||||
_writeParameters();
|
||||
'Future<List<${select.resultTypeCode(scope.generationOptions)}>>';
|
||||
_buffer.write('$returnType ${select.name}(');
|
||||
_writeParameters(select);
|
||||
_buffer
|
||||
..write(') {\n')
|
||||
..write('return ${_nameOfCreationMethod()}(');
|
||||
_writeUseParameters();
|
||||
..write('return ${_nameOfCreationMethod(select)}(');
|
||||
_writeUseParameters(select);
|
||||
_buffer.write(').get();\n}\n');
|
||||
}
|
||||
|
||||
void _writeStreamReader() {
|
||||
final upperQueryName = ReCase(query.name).pascalCase;
|
||||
void _writeStreamReader(SqlSelectQuery select) {
|
||||
final upperQueryName = ReCase(select.name).pascalCase;
|
||||
|
||||
String methodName;
|
||||
// turning the query name into pascal case will remove underscores, add the
|
||||
// "private" modifier back in
|
||||
if (query.name.startsWith('_')) {
|
||||
if (select.name.startsWith('_')) {
|
||||
methodName = '_watch$upperQueryName';
|
||||
} else {
|
||||
methodName = 'watch$upperQueryName';
|
||||
}
|
||||
|
||||
final returnType =
|
||||
'Stream<List<${_select.resultTypeCode(scope.generationOptions)}>>';
|
||||
'Stream<List<${select.resultTypeCode(scope.generationOptions)}>>';
|
||||
_buffer.write('$returnType $methodName(');
|
||||
_writeParameters();
|
||||
_writeParameters(select);
|
||||
_buffer
|
||||
..write(') {\n')
|
||||
..write('return ${_nameOfCreationMethod()}(');
|
||||
_writeUseParameters();
|
||||
..write('return ${_nameOfCreationMethod(select)}(');
|
||||
_writeUseParameters(select);
|
||||
_buffer.write(').watch();\n}\n');
|
||||
}
|
||||
|
||||
void _writeUpdatingQueryWithReturning() {
|
||||
final type = query.resultTypeCode(scope.generationOptions);
|
||||
_buffer.write('Future<List<$type>> ${query.name}(');
|
||||
_writeParameters();
|
||||
void _writeUpdatingQueryWithReturning(UpdatingQuery update) {
|
||||
final type = update.resultTypeCode(scope.generationOptions);
|
||||
_buffer.write('Future<List<$type>> ${update.name}(');
|
||||
_writeParameters(update);
|
||||
_buffer.write(') {\n');
|
||||
|
||||
_writeExpandedDeclarations();
|
||||
_buffer.write('return customWriteReturning(${_queryCode()},');
|
||||
_writeCommonUpdateParameters();
|
||||
_writeExpandedDeclarations(update);
|
||||
_buffer.write('return customWriteReturning(${_queryCode(update)},');
|
||||
_writeCommonUpdateParameters(update);
|
||||
_buffer.write(').then((rows) => rows.map(');
|
||||
_writeMappingLambda();
|
||||
_writeMappingLambda(update);
|
||||
_buffer.write(').toList());\n}');
|
||||
}
|
||||
|
||||
void _writeUpdatingQuery() {
|
||||
void _writeUpdatingQuery(UpdatingQuery update) {
|
||||
/*
|
||||
Future<int> test() {
|
||||
return customUpdate('', variables: [], updates: {});
|
||||
}
|
||||
*/
|
||||
final implName = _update.isInsert ? 'customInsert' : 'customUpdate';
|
||||
final implName = update.isInsert ? 'customInsert' : 'customUpdate';
|
||||
|
||||
_buffer.write('Future<int> ${query.name}(');
|
||||
_writeParameters();
|
||||
_buffer.write('Future<int> ${update.name}(');
|
||||
_writeParameters(update);
|
||||
_buffer.write(') {\n');
|
||||
|
||||
_writeExpandedDeclarations();
|
||||
_buffer.write('return $implName(${_queryCode()},');
|
||||
_writeCommonUpdateParameters();
|
||||
_writeExpandedDeclarations(update);
|
||||
_buffer.write('return $implName(${_queryCode(update)},');
|
||||
_writeCommonUpdateParameters(update);
|
||||
_buffer.write(',);\n}\n');
|
||||
}
|
||||
|
||||
void _writeCommonUpdateParameters() {
|
||||
_writeVariables();
|
||||
void _writeCommonUpdateParameters(UpdatingQuery update) {
|
||||
_writeVariables(update);
|
||||
_buffer.write(',');
|
||||
_writeUpdates();
|
||||
_writeUpdateKind();
|
||||
_writeUpdates(update);
|
||||
_writeUpdateKind(update);
|
||||
}
|
||||
|
||||
void _writeParameters() {
|
||||
void _writeParameters(SqlQuery query) {
|
||||
final namedElements = <FoundElement>[];
|
||||
|
||||
String typeFor(FoundElement element) {
|
||||
|
|
@ -407,35 +422,37 @@ class QueryWriter {
|
|||
/// Writes code that uses the parameters as declared by [_writeParameters],
|
||||
/// assuming that for each parameter, a variable with the same name exists
|
||||
/// in the current scope.
|
||||
void _writeUseParameters() {
|
||||
void _writeUseParameters(SqlQuery query) {
|
||||
final parameters = query.elements.map((e) => e.dartParameterName);
|
||||
_buffer.write(parameters.join(', '));
|
||||
}
|
||||
|
||||
void _writeExpandedDeclarations() {
|
||||
void _writeExpandedDeclarations(SqlQuery query) {
|
||||
_ExpandedDeclarationWriter(query, options, _buffer)
|
||||
.writeExpandedDeclarations();
|
||||
}
|
||||
|
||||
void _writeVariables() {
|
||||
void _writeVariables(SqlQuery query) {
|
||||
_ExpandedVariableWriter(query, scope, _buffer).writeVariables();
|
||||
}
|
||||
|
||||
/// Returns a Dart string literal representing the query after variables have
|
||||
/// been expanded. For instance, 'SELECT * FROM t WHERE x IN ?' will be turned
|
||||
/// into 'SELECT * FROM t WHERE x IN ($expandedVar1)'.
|
||||
String _queryCode() {
|
||||
String _queryCode(SqlQuery query) {
|
||||
if (scope.options.newSqlCodeGeneration) {
|
||||
return SqlWriter(scope.options, query: query).write();
|
||||
} else {
|
||||
return _legacyQueryCode();
|
||||
return _legacyQueryCode(query);
|
||||
}
|
||||
}
|
||||
|
||||
String _legacyQueryCode() {
|
||||
final context = query.fromContext!;
|
||||
String _legacyQueryCode(SqlQuery query) {
|
||||
final root = query.root!;
|
||||
final sql = query.fromContext!.sql;
|
||||
|
||||
// sort variables and placeholders by the order in which they appear
|
||||
final toReplace = context.root.allDescendants
|
||||
final toReplace = root.allDescendants
|
||||
.where((node) =>
|
||||
node is Variable ||
|
||||
node is DartPlaceholder ||
|
||||
|
|
@ -450,17 +467,17 @@ class QueryWriter {
|
|||
const <NestedStarResultColumn, NestedResultTable>{};
|
||||
if (query is SqlSelectQuery) {
|
||||
doubleStarColumnToResolvedTable = {
|
||||
for (final nestedResult in _select.resultSet.nestedResults)
|
||||
nestedResult.from: nestedResult
|
||||
for (final nestedResult in query.resultSet.nestedResults)
|
||||
if (nestedResult is NestedResultTable) nestedResult.from: nestedResult
|
||||
};
|
||||
}
|
||||
|
||||
var lastIndex = context.root.firstPosition;
|
||||
var lastIndex = root.firstPosition;
|
||||
|
||||
void replaceNode(AstNode node, String content) {
|
||||
// write everything that comes before this var into the buffer
|
||||
final currentIndex = node.firstPosition;
|
||||
final queryPart = context.sql.substring(lastIndex, currentIndex);
|
||||
final queryPart = sql.substring(lastIndex, currentIndex);
|
||||
buffer.write(escapeForDart(queryPart));
|
||||
lastIndex = node.lastPosition;
|
||||
|
||||
|
|
@ -486,7 +503,9 @@ class QueryWriter {
|
|||
final result = doubleStarColumnToResolvedTable[rewriteTarget];
|
||||
if (result == null) continue;
|
||||
|
||||
final prefix = _select.resultSet.nestedPrefixFor(result);
|
||||
// weird cast here :O
|
||||
final prefix =
|
||||
(query as SqlSelectQuery).resultSet.nestedPrefixFor(result);
|
||||
final table = rewriteTarget.tableName;
|
||||
|
||||
// Convert foo.** to "foo.a" AS "nested_0.a", ... for all columns in foo
|
||||
|
|
@ -509,40 +528,40 @@ class QueryWriter {
|
|||
}
|
||||
|
||||
// write the final part after the last variable, plus the ending '
|
||||
final lastPosition = context.root.lastPosition;
|
||||
final lastPosition = root.lastPosition;
|
||||
buffer
|
||||
..write(escapeForDart(context.sql.substring(lastIndex, lastPosition)))
|
||||
..write(escapeForDart(sql.substring(lastIndex, lastPosition)))
|
||||
..write("'");
|
||||
|
||||
return buffer.toString();
|
||||
}
|
||||
|
||||
void _writeReadsFrom() {
|
||||
void _writeReadsFrom(SqlSelectQuery select) {
|
||||
_buffer.write('readsFrom: {');
|
||||
|
||||
for (final table in _select.readsFromTables) {
|
||||
for (final table in select.readsFromTables) {
|
||||
_buffer.write('${table.dbGetterName},');
|
||||
}
|
||||
|
||||
for (final element in query.elements.whereType<FoundDartPlaceholder>()) {
|
||||
for (final element in select.elements.whereType<FoundDartPlaceholder>()) {
|
||||
_buffer.write('...${placeholderContextName(element)}.watchedTables,');
|
||||
}
|
||||
|
||||
_buffer.write('}');
|
||||
}
|
||||
|
||||
void _writeUpdates() {
|
||||
final from = _update.updates.map((t) => t.table.dbGetterName).join(', ');
|
||||
void _writeUpdates(UpdatingQuery update) {
|
||||
final from = update.updates.map((t) => t.table.dbGetterName).join(', ');
|
||||
_buffer
|
||||
..write('updates: {')
|
||||
..write(from)
|
||||
..write('}');
|
||||
}
|
||||
|
||||
void _writeUpdateKind() {
|
||||
if (_update.isOnlyDelete) {
|
||||
void _writeUpdateKind(UpdatingQuery update) {
|
||||
if (update.isOnlyDelete) {
|
||||
_buffer.write(', updateKind: UpdateKind.delete');
|
||||
} else if (_update.isOnlyUpdate) {
|
||||
} else if (update.isOnlyUpdate) {
|
||||
_buffer.write(', updateKind: UpdateKind.update');
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,17 +39,32 @@ class ResultSetWriter {
|
|||
}
|
||||
|
||||
for (final nested in resultSet.nestedResults) {
|
||||
var typeName = nested.table.dartTypeCode(scope.generationOptions);
|
||||
final fieldName = nested.dartFieldName;
|
||||
if (nested is NestedResultTable) {
|
||||
var typeName = nested.table.dartTypeCode(scope.generationOptions);
|
||||
final fieldName = nested.dartFieldName;
|
||||
|
||||
if (nested.isNullable) {
|
||||
typeName = scope.nullableType(typeName);
|
||||
if (nested.isNullable) {
|
||||
typeName = scope.nullableType(typeName);
|
||||
}
|
||||
|
||||
into.write('$modifier $typeName $fieldName;\n');
|
||||
|
||||
fieldNames.add(fieldName);
|
||||
if (!nested.isNullable) nonNullableFields.add(fieldName);
|
||||
} else if (nested is NestedResultQuery) {
|
||||
final nestedPrefix = resultSet.nestedPrefixFor(nested);
|
||||
final fieldName = nested.filedName(nestedPrefix);
|
||||
final typeName = nested.resultTypeCode(className);
|
||||
|
||||
if (nested.query.resultSet.needsOwnClass) {
|
||||
ResultSetWriter(nested.query, scope).write();
|
||||
}
|
||||
|
||||
into.write('$modifier List<$typeName> $fieldName;\n');
|
||||
|
||||
fieldNames.add(fieldName);
|
||||
nonNullableFields.add(fieldName);
|
||||
}
|
||||
|
||||
into.write('$modifier $typeName $fieldName;\n');
|
||||
|
||||
fieldNames.add(fieldName);
|
||||
if (!nested.isNullable) nonNullableFields.add(fieldName);
|
||||
}
|
||||
|
||||
// write the constructor
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class SqlWriter extends NodeSqlBuilder {
|
|||
if (query is SqlSelectQuery) {
|
||||
doubleStarColumnToResolvedTable = {
|
||||
for (final nestedResult in query.resultSet.nestedResults)
|
||||
nestedResult.from: nestedResult
|
||||
if (nestedResult is NestedResultTable) nestedResult.from: nestedResult
|
||||
};
|
||||
}
|
||||
return SqlWriter._(query, options, doubleStarColumnToResolvedTable,
|
||||
|
|
@ -54,7 +54,7 @@ class SqlWriter extends NodeSqlBuilder {
|
|||
}
|
||||
|
||||
String write() {
|
||||
return writeNodeIntoStringLiteral(query!.fromContext!.root);
|
||||
return writeNodeIntoStringLiteral(query!.root!);
|
||||
}
|
||||
|
||||
String writeNodeIntoStringLiteral(AstNode node) {
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ void main() {
|
|||
|
||||
test('warns when a result column is unresolved', () {
|
||||
final result = engine.analyze('SELECT ?;');
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(moorQuery.lints,
|
||||
anyElement((AnalysisError q) => q.message.contains('unknown type')));
|
||||
|
|
@ -25,7 +25,7 @@ void main() {
|
|||
|
||||
test('warns when the result depends on a Dart template', () {
|
||||
final result = engine.analyze(r"SELECT 'string' = $expr;");
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(moorQuery.lints,
|
||||
anyElement((AnalysisError q) => q.message.contains('Dart template')));
|
||||
|
|
@ -33,7 +33,7 @@ void main() {
|
|||
|
||||
test('warns when nested results refer to table-valued functions', () {
|
||||
final result = engine.analyze("SELECT json_each.** FROM json_each('')");
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(
|
||||
moorQuery.lints,
|
||||
|
|
@ -95,7 +95,7 @@ in: INSERT INTO foo (id) $placeholder;
|
|||
group('warns about wrong types in subexpressions', () {
|
||||
test('strings in arithmetic', () {
|
||||
final result = engine.analyze("SELECT 'foo' + 3;");
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(
|
||||
moorQuery.lints,
|
||||
|
|
@ -106,14 +106,14 @@ in: INSERT INTO foo (id) $placeholder;
|
|||
|
||||
test('allows numerics in arithmetic', () {
|
||||
final result = engine.analyze('SELECT 3.6 * 3;');
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(moorQuery.lints, isEmpty);
|
||||
});
|
||||
|
||||
test('real in binary', () {
|
||||
final result = engine.analyze('SELECT 3.5 | 3;');
|
||||
final moorQuery = QueryHandler(fakeQuery, result, mapper).handle();
|
||||
final moorQuery = QueryHandler(result, mapper).handle(fakeQuery);
|
||||
|
||||
expect(
|
||||
moorQuery.lints,
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ Future<void> main() async {
|
|||
SqlQuery parse(String sql) {
|
||||
final parsed = engine.analyze(sql);
|
||||
final fakeQuery = DeclaredDartQuery('query', sql);
|
||||
return QueryHandler(fakeQuery, parsed, mapper).handle();
|
||||
return QueryHandler(parsed, mapper).handle(fakeQuery);
|
||||
}
|
||||
|
||||
group('detects whether multiple tables are referenced', () {
|
||||
|
|
@ -105,9 +105,16 @@ FROM routes
|
|||
|
||||
expect(resultSet.columns.map((e) => e.name), ['id', 'from', 'to']);
|
||||
expect(resultSet.matchingTable, isNull);
|
||||
expect(resultSet.nestedResults.map((e) => e.name), ['from', 'to']);
|
||||
expect(resultSet.nestedResults.map((e) => e.table.displayName),
|
||||
['points', 'points']);
|
||||
expect(
|
||||
resultSet.nestedResults.cast<NestedResultTable>().map((e) => e.name),
|
||||
['from', 'to'],
|
||||
);
|
||||
expect(
|
||||
resultSet.nestedResults
|
||||
.cast<NestedResultTable>()
|
||||
.map((e) => e.table.displayName),
|
||||
['points', 'points'],
|
||||
);
|
||||
});
|
||||
|
||||
test('resolves nullability of aliases in nested result sets', () async {
|
||||
|
|
@ -144,9 +151,14 @@ LEFT JOIN tableB1 AS tableB2 -- nullable
|
|||
final resultSet = (query as SqlSelectQuery).resultSet;
|
||||
|
||||
final nested = resultSet.nestedResults;
|
||||
expect(nested.map((e) => e.name),
|
||||
['tableA1', 'tableA2', 'tableB1', 'tableB2']);
|
||||
expect(nested.map((e) => e.isNullable), [false, true, false, true]);
|
||||
expect(
|
||||
nested.cast<NestedResultTable>().map((e) => e.name),
|
||||
['tableA1', 'tableA2', 'tableB1', 'tableB2'],
|
||||
);
|
||||
expect(
|
||||
nested.cast<NestedResultTable>().map((e) => e.isNullable),
|
||||
[false, true, false, true],
|
||||
);
|
||||
});
|
||||
|
||||
test('infers result set for views', () async {
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ void main() {
|
|||
final writer = Writer(
|
||||
const MoorOptions.defaults(generateNamedParameters: true),
|
||||
generationOptions: const GenerationOptions(nnbd: true));
|
||||
QueryWriter(fileState.resolvedQueries!.single, writer.child()).write();
|
||||
QueryWriter(writer.child()).write(fileState.resolvedQueries!.single);
|
||||
|
||||
expect(writer.writeGenerated(), contains('required List<int?> idList'));
|
||||
});
|
||||
|
|
@ -47,7 +47,7 @@ void main() {
|
|||
final writer = Writer(
|
||||
const MoorOptions.defaults(newSqlCodeGeneration: true),
|
||||
generationOptions: const GenerationOptions(nnbd: true));
|
||||
QueryWriter(fileState.resolvedQueries!.single, writer.child()).write();
|
||||
QueryWriter(writer.child()).write(fileState.resolvedQueries!.single);
|
||||
|
||||
expect(
|
||||
writer.writeGenerated(),
|
||||
|
|
@ -76,7 +76,7 @@ void main() {
|
|||
final writer = Writer(
|
||||
const MoorOptions.defaults(newSqlCodeGeneration: true),
|
||||
generationOptions: const GenerationOptions(nnbd: true));
|
||||
QueryWriter(fileState.resolvedQueries!.single, writer.child()).write();
|
||||
QueryWriter(writer.child()).write(fileState.resolvedQueries!.single);
|
||||
|
||||
expect(
|
||||
writer.writeGenerated(),
|
||||
|
|
@ -116,7 +116,7 @@ void main() {
|
|||
options,
|
||||
generationOptions: const GenerationOptions(nnbd: true),
|
||||
);
|
||||
QueryWriter(fileState.resolvedQueries!.single, writer.child()).write();
|
||||
QueryWriter(writer.child()).write(fileState.resolvedQueries!.single);
|
||||
|
||||
expect(writer.writeGenerated(), expectation);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ void main() {
|
|||
void check(String sql, String expectedDart) {
|
||||
final engine = SqlEngine();
|
||||
final context = engine.analyze(sql);
|
||||
final query = SqlSelectQuery(
|
||||
'name', context, [], [], InferredResultSet(null, []), null);
|
||||
final query = SqlSelectQuery('name', context, context.root, [], [],
|
||||
InferredResultSet(null, []), null);
|
||||
|
||||
final result =
|
||||
SqlWriter(const MoorOptions.defaults(), query: query).write();
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
import '../../../sqlparser.dart';
|
||||
import '../ast.dart' show ResultColumn, Renamable;
|
||||
import '../../analysis/analysis.dart';
|
||||
import '../ast.dart'
|
||||
show StarResultColumn, ResultColumn, Renamable, SelectStatement;
|
||||
import '../node.dart';
|
||||
import '../visitor.dart';
|
||||
import 'moor_file.dart';
|
||||
|
|
|
|||
Loading…
Reference in New Issue