Add isOpen() method for transactions.

Author: rkistner

lib/src/connection_pool.dart

@@ -49,6 +49,11 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
       : _writeConnection = writeConnection,
         _upstreamPort = upstreamPort;
 
+  @override
+  Future<bool> isOpen() async {
+    return !closed;
+  }
+
   @override
   Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) async {

lib/src/sqlite_connection.dart

@@ -13,6 +13,15 @@ abstract class SqliteReadContext {
   Future<sqlite.Row?> getOptional(String sql,
       [List<Object?> parameters = const []]);
 
+  /// For transactions, returns true if the transaction is open.
+  ///
+  /// This means the lock is still held, and the transaction has not been committed
+  /// or rolled back (whether explicit rollback, or because of an error).
+  ///
+  /// For database connections, returns true if the connection hasn't been closed
+  /// yet.
+  Future<bool> isOpen();
+
   /// Run a function within a database isolate, with direct synchronous access
   /// to the underlying database.
   ///

lib/src/sqlite_connection_impl.dart

@@ -49,6 +49,11 @@ class SqliteConnectionImpl with SqliteQueries implements SqliteConnection {
     return _isolateClient.closed;
   }
 
+  @override
+  Future<bool> isOpen() async {
+    return !closed;
+  }
+
   Future<void> _open(SqliteOpenFactory openFactory,
       {required bool primary,
       required SerializedPortClient upstreamPort}) async {
@@ -176,6 +181,13 @@ class _TransactionContext implements SqliteWriteContext {
     }
   }
 
+  @override
+  Future<bool> isOpen() {
+    return computeWithDatabase((db) async {
+      return !db.autocommit;
+    });
+  }
+
   @override
   Future<T> computeWithDatabase<T>(
       Future<T> Function(sqlite.Database db) compute) async {

lib/src/sqlite_database.dart

@@ -109,6 +109,11 @@ class SqliteDatabase with SqliteQueries implements SqliteConnection {
     return _pool.closed;
   }
 
+  @override
+  Future<bool> isOpen() async {
+    return !closed;
+  }
+
   void _listenForEvents() {
     UpdateNotification? updates;
 

test/basic_test.dart

@@ -222,15 +222,21 @@ void main() {
       await createTables(db);
 
       var tp = db.writeTransaction((tx) async {
-        tx.execute(
+        await tx.execute(
             'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
             [1, 'test1']);
-        tx.execute(
+        await tx.execute(
             'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
             [2, 'test2']);
-        ignore(tx.execute(
-            'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
-            [2, 'test3'])); // Errors
+        expect(await tx.isOpen(), equals(true));
+        try {
+          await tx.execute(
+              'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
+              [2, 'test3']);
+        } catch (e) {
+          // Ignore
+        }
+        expect(await tx.isOpen(), equals(false));
 
         // Will not be executed because of the above rollback
         ignore(tx.execute(
@@ -337,7 +343,9 @@ void main() {
     test('should allow resuming transaction after errors', () async {
       final db = await setupDatabase(path: path);
       await createTables(db);
+      SqliteWriteContext? savedTx;
       await db.writeTransaction((tx) async {
+        savedTx = tx;
         var caught = false;
         try {
           // This error does not rollback the transaction
@@ -348,11 +356,14 @@ void main() {
         }
         expect(caught, equals(true));
 
+        expect(await tx.isOpen(), equals(true));
+
         final rs = await tx.execute(
             'INSERT INTO test_data(description) VALUES(?) RETURNING description',
             ['Test Data']);
         expect(rs.rows[0], equals(['Test Data']));
       });
+      expect(await savedTx!.isOpen(), equals(false));
     });
   });
 }