Merge branch 'develop' into ffi

moor/lib/src/runtime/database.dart

@@ -234,13 +234,23 @@ mixin QueryEngine on DatabaseConnectionUser {
 
     final executor = resolved.executor;
     await executor.doWhenOpened((executor) {
-      final transaction = Transaction(this, executor.beginTransaction());
+      final transactionExecutor = executor.beginTransaction();
+      final transaction = Transaction(this, transactionExecutor);
 
       return _runEngineZoned(transaction, () async {
+        var success = false;
         try {
           await action(transaction);
+          success = true;
+        } catch (e) {
+          await transactionExecutor.rollback();
+          // pass the exception on to the one who called transaction()
+          rethrow;
         } finally {
-          await transaction.complete();
+          if (success) {
+            // calling complete will also take care of committing the transaction
+            await transaction.complete();
+          }
         }
       });
     });

moor/lib/src/runtime/executor/executor.dart

@@ -93,4 +93,8 @@ abstract class TransactionExecutor extends QueryExecutor {
   /// Completes the transaction. No further queries may be sent to to this
   /// [QueryExecutor] after this method was called.
   Future<void> send();
+
+  /// Cancels this transaction. No further queries may be sent ot this
+  /// [QueryExecutor] after this method was called.
+  Future<void> rollback();
 }

moor/lib/src/runtime/executor/helpers/delegates.dart

@@ -106,8 +106,15 @@ class NoTransactionDelegate extends TransactionDelegate {
   /// The statement that commits a transaction on this database engine.
   final String commit;
 
-  const NoTransactionDelegate(
-      {this.start = 'BEGIN TRANSACTION', this.commit = 'COMMIT TRANSACTION'});
+  /// The statement that will perform a rollback of a transaction on this
+  /// database engine.
+  final String rollback;
+
+  const NoTransactionDelegate({
+    this.start = 'BEGIN TRANSACTION',
+    this.commit = 'COMMIT TRANSACTION',
+    this.rollback = 'ROLLBACK TRANSACTION',
+  });
 }
 
 /// A [TransactionDelegate] for database APIs which do support creating and

moor/lib/src/runtime/executor/helpers/engines.dart

@@ -98,6 +98,7 @@ class _TransactionExecutor extends TransactionExecutor
   Completer<bool> _openingCompleter;
 
   String _sendOnCommit;
+  String _sendOnRollback;
 
   Future get completed => _sendCalled.future;
 
@@ -130,6 +131,7 @@ class _TransactionExecutor extends TransactionExecutor
         impl = _db.delegate;
         await impl.runCustom(transactionManager.start, const []);
         _sendOnCommit = transactionManager.commit;
+        _sendOnRollback = transactionManager.rollback;
 
         transactionStarted.complete();
 
@@ -162,6 +164,16 @@ class _TransactionExecutor extends TransactionExecutor
 
     _sendCalled.complete();
   }
+
+  @override
+  Future<void> rollback() async {
+    if (_sendOnRollback != null) {
+      await impl.runCustom(_sendOnRollback, const []);
+    }
+
+    _sendCalled.completeError(
+        Exception('artificial exception to rollback the transaction'));
+  }
 }
 
 class _BeforeOpeningExecutor extends QueryExecutor

moor/test/data/utils/mocks.dart

@@ -39,6 +39,7 @@ class MockTransactionExecutor extends Mock implements TransactionExecutor {
     });
 
     when(send()).thenAnswer((_) => Future.value(null));
+    when(rollback()).thenAnswer((_) => Future.value(null));
   }
 }
 

moor/test/transactions_test.dart

@@ -33,13 +33,10 @@ void main() {
 
   test("transactions don't allow creating streams", () {
     expect(() async {
-      await db.transaction((t) {
+      await db.transaction((t) async {
         t.select(db.users).watch();
-        return Future.value(null); // analysis warning in travis otherwise
       });
     }, throwsStateError);
-
-    verify(executor.transactions.send());
   });
 
   test('nested transactions use the outer transaction', () async {
@@ -66,6 +63,18 @@ void main() {
     verify(executor.transactions.runSelect(any, any));
   });
 
+  test('transactions rollback after errors', () async {
+    final exception = Exception('oh no');
+    final future = db.transaction((_) async {
+      throw exception;
+    });
+
+    await expectLater(future, throwsA(exception));
+
+    verifyNever(executor.transactions.send());
+    verify(executor.transactions.rollback());
+  });
+
   test('transactions notify about table udpates after completing', () async {
     when(executor.transactions.runUpdate(any, any))
         .thenAnswer((_) => Future.value(2));