From 9494768a321ee4b9a82db3990b7ffb253e46e564 Mon Sep 17 00:00:00 2001 From: Simon Binder Date: Sat, 1 Feb 2020 15:56:30 +0100 Subject: [PATCH] Start work on pooled connections --- moor/lib/connection_pool.dart | 26 +++++ .../executor/connection_pool_impl.dart | 96 +++++++++++++++++++ .../lib/src/model/declarations/index.dart | 2 - .../model/declarations/special_queries.dart | 2 - .../lib/src/model/declarations/trigger.dart | 2 - 5 files changed, 122 insertions(+), 6 deletions(-) create mode 100644 moor/lib/connection_pool.dart create mode 100644 moor/lib/src/runtime/executor/connection_pool_impl.dart diff --git a/moor/lib/connection_pool.dart b/moor/lib/connection_pool.dart new file mode 100644 index 00000000..52af6a6c --- /dev/null +++ b/moor/lib/connection_pool.dart @@ -0,0 +1,26 @@ +/// Support library to support pooled connections with moor. +/// +/// Note that using a pooled connection is not necessary for most moor apps. +@experimental +library connection_pool; + +import 'package:meta/meta.dart'; +import 'package:moor/backends.dart'; +import 'package:moor/moor.dart'; + +part 'src/runtime/executor/connection_pool_impl.dart'; + +/// A query executor for moor that delegates work to multiple executors. +abstract class MultiExecutor extends QueryExecutor { + /// Creates a query executor that will delegate work to different executors. + /// + /// Updating statements, or statements that run in a transaction, will be run + /// with [write]. Select statements outside of a transaction are executed on + /// [read]. + factory MultiExecutor( + {@required QueryExecutor read, @required QueryExecutor write}) { + return _MultiExecutorImpl(read, write); + } + + MultiExecutor._(); +} diff --git a/moor/lib/src/runtime/executor/connection_pool_impl.dart b/moor/lib/src/runtime/executor/connection_pool_impl.dart new file mode 100644 index 00000000..34dedb18 --- /dev/null +++ b/moor/lib/src/runtime/executor/connection_pool_impl.dart @@ -0,0 +1,96 @@ +part of 'package:moor/connection_pool.dart'; + +class _MultiExecutorImpl extends MultiExecutor { + final QueryExecutor _reads; + final QueryExecutor _writes; + + _MultiExecutorImpl(this._reads, this._writes) : super._(); + + @override + set databaseInfo(GeneratedDatabase database) { + super.databaseInfo = database; + + _writes.databaseInfo = database; + _reads.databaseInfo = _NoMigrationsWrapper(database); + } + + @override + Future ensureOpen() async { + // note: It's crucial that we open the writes first. The reading connection + // doesn't run migrations, but has to set the user version. + await _writes.ensureOpen(); + await _reads.ensureOpen(); + + return true; + } + + @override + TransactionExecutor beginTransaction() { + return _writes.beginTransaction(); + } + + @override + Future runBatched(List statements) async { + await _writes.runBatched(statements); + } + + @override + Future runCustom(String statement, [List args]) async { + await _writes.runCustom(statement, args); + } + + @override + Future runDelete(String statement, List args) async { + return await _writes.runDelete(statement, args); + } + + @override + Future runInsert(String statement, List args) async { + return await _writes.runInsert(statement, args); + } + + @override + Future>> runSelect( + String statement, List args) async { + return await _reads.runSelect(statement, args); + } + + @override + Future runUpdate(String statement, List args) async { + return await _writes.runUpdate(statement, args); + } + + @override + Future close() async { + await _writes.close(); + await _reads.close(); + } +} + +// query executors are responsible for starting the migration process on +// a database after they open. We don't want to run migrations twice, so +// we give the reading executor a database handle that doesn't do any +// migrations. +class _NoMigrationsWrapper extends GeneratedDatabase { + final GeneratedDatabase _inner; + + _NoMigrationsWrapper(this._inner) + : super(const SqlTypeSystem.withDefaults(), null); + + @override + Iterable> get allTables => const []; + + @override + int get schemaVersion => _inner.schemaVersion; + + @override + Future handleDatabaseCreation({@required SqlExecutor executor}) async {} + + @override + Future handleDatabaseVersionChange( + {@required SqlExecutor executor, int from, int to}) async {} + + @override + Future beforeOpenCallback( + QueryExecutor executor, OpeningDetails details) async {} +} diff --git a/moor_generator/lib/src/model/declarations/index.dart b/moor_generator/lib/src/model/declarations/index.dart index 2ce23a47..3c6fdd6d 100644 --- a/moor_generator/lib/src/model/declarations/index.dart +++ b/moor_generator/lib/src/model/declarations/index.dart @@ -9,8 +9,6 @@ class MoorIndexDeclaration implements MoorDeclaration, IndexDeclaration { @override final CreateIndexStatement node; - MoorIndexDeclaration._(this.declaration, this.node); - MoorIndexDeclaration.fromNodeAndFile(this.node, FoundFile file) : declaration = SourceRange.fromNodeAndFile(node, file); } diff --git a/moor_generator/lib/src/model/declarations/special_queries.dart b/moor_generator/lib/src/model/declarations/special_queries.dart index 8bd80902..69f5b785 100644 --- a/moor_generator/lib/src/model/declarations/special_queries.dart +++ b/moor_generator/lib/src/model/declarations/special_queries.dart @@ -10,8 +10,6 @@ class MoorSpecialQueryDeclaration @override final DeclaredStatement node; - MoorSpecialQueryDeclaration._(this.declaration, this.node); - MoorSpecialQueryDeclaration.fromNodeAndFile(this.node, FoundFile file) : declaration = SourceRange.fromNodeAndFile(node, file); } diff --git a/moor_generator/lib/src/model/declarations/trigger.dart b/moor_generator/lib/src/model/declarations/trigger.dart index 9af45355..542c4db8 100644 --- a/moor_generator/lib/src/model/declarations/trigger.dart +++ b/moor_generator/lib/src/model/declarations/trigger.dart @@ -9,8 +9,6 @@ class MoorTriggerDeclaration implements MoorDeclaration, TriggerDeclaration { @override final CreateTriggerStatement node; - MoorTriggerDeclaration._(this.declaration, this.node); - MoorTriggerDeclaration.fromNodeAndFile(this.node, FoundFile file) : declaration = SourceRange.fromNodeAndFile(node, file); }