Add tx.closed and db/tx.getAutoCommit().

Author: rkistner

lib/src/connection_pool.dart

@@ -49,9 +49,13 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
       : _writeConnection = writeConnection,
         _upstreamPort = upstreamPort;
 
+  /// Returns true if the _write_ connection is currently in autocommit mode.
   @override
-  Future<bool> isOpen() async {
-    return !closed;
+  Future<bool> getAutoCommit() async {
+    if (_writeConnection == null) {
+      throw AssertionError('Closed');
+    }
+    return await _writeConnection!.getAutoCommit();
   }
 
   @override

lib/src/sqlite_connection.dart

@@ -13,14 +13,17 @@ 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 transactions, returns true if the lock is held (even if it has been
+  /// rolled back).
   ///
   /// For database connections, returns true if the connection hasn't been closed
   /// yet.
-  Future<bool> isOpen();
+  bool get closed;
+
+  /// Returns true if auto-commit is enabled. This means the database is not
+  /// currently in a transaction. This may be true even if a transaction lock
+  /// is still held, when the transaction has been committed or rolled back.
+  Future<bool> getAutoCommit();
 
   /// Run a function within a database isolate, with direct synchronous access
   /// to the underlying database.
@@ -114,5 +117,6 @@ abstract class SqliteConnection extends SqliteWriteContext {
   Future<void> close();
 
   /// Returns true if the connection is closed
+  @override
   bool get closed;
 }

lib/src/sqlite_connection_impl.dart

@@ -50,8 +50,18 @@ class SqliteConnectionImpl with SqliteQueries implements SqliteConnection {
   }
 
   @override
-  Future<bool> isOpen() async {
-    return !closed;
+  Future<bool> getAutoCommit() async {
+    if (closed) {
+      throw AssertionError('Closed');
+    }
+    // We use a _TransactionContext without a lock here.
+    // It is safe to call this in the middle of another transaction.
+    final ctx = _TransactionContext(_isolateClient);
+    try {
+      return await ctx.getAutoCommit();
+    } finally {
+      await ctx.close();
+    }
   }
 
   Future<void> _open(SqliteOpenFactory openFactory,
@@ -150,6 +160,11 @@ class _TransactionContext implements SqliteWriteContext {
 
   _TransactionContext(this._sendPort);
 
+  @override
+  bool get closed {
+    return _closed;
+  }
+
   @override
   Future<sqlite.ResultSet> execute(String sql,
       [List<Object?> parameters = const []]) async {
@@ -182,10 +197,12 @@ class _TransactionContext implements SqliteWriteContext {
   }
 
   @override
-  Future<bool> isOpen() {
-    return computeWithDatabase((db) async {
-      return !db.autocommit;
-    });
+  Future<bool> getAutoCommit() async {
+    return await computeWithDatabase(
+      (db) async {
+        return db.autocommit;
+      },
+    );
   }
 
   @override

lib/src/sqlite_database.dart

@@ -109,9 +109,11 @@ class SqliteDatabase with SqliteQueries implements SqliteConnection {
     return _pool.closed;
   }
 
+  /// Returns true if the _write_ connection is in auto-commit mode
+  /// (no active transaction).
   @override
-  Future<bool> isOpen() async {
-    return !closed;
+  Future<bool> getAutoCommit() {
+    return _pool.getAutoCommit();
   }
 
   void _listenForEvents() {

test/basic_test.dart

@@ -228,15 +228,16 @@ void main() {
         await tx.execute(
             'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
             [2, 'test2']);
-        expect(await tx.isOpen(), equals(true));
+        expect(await tx.getAutoCommit(), equals(false));
         try {
           await tx.execute(
               'INSERT OR ROLLBACK INTO test_data(id, description) VALUES(?, ?)',
               [2, 'test3']);
         } catch (e) {
           // Ignore
         }
-        expect(await tx.isOpen(), equals(false));
+        expect(await tx.getAutoCommit(), equals(true));
+        expect(tx.closed, equals(false));
 
         // Will not be executed because of the above rollback
         ignore(tx.execute(
@@ -356,14 +357,16 @@ void main() {
         }
         expect(caught, equals(true));
 
-        expect(await tx.isOpen(), equals(true));
+        expect(await tx.getAutoCommit(), equals(false));
+        expect(tx.closed, equals(false));
 
         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));
+      expect(await savedTx!.getAutoCommit(), equals(true));
+      expect(savedTx!.closed, equals(true));
     });
   });
 }