Merge branch 'dispose-database-tracker' into develop

Author: simolus3

drift/CHANGELOG.md

@@ -7,6 +7,7 @@
   JSON.
 - Add `runWithInterceptor` method to databases to only apply interceptors in
   a restricted block.
+- Add `dispose()` method to `DatabaseTracker` to explicitly release in-memory SQLite resources.
 
 ## 2.23.1
 

drift/lib/native.dart

@@ -356,10 +356,12 @@ class _NativeDelegate extends Sqlite3Delegate<Database> {
       }
 
       db = sqlite3.open(file.path);
-      try {
-        tracker.markOpened(file.path, db);
-      } on SqliteException {
-        // ignore
+      if (!tracker.isDisposed) {
+        try {
+          tracker.markOpened(file.path, db);
+        } on SqliteException {
+          // ignore
+        }
       }
     } else {
       db = sqlite3.openInMemory();
@@ -399,10 +401,12 @@ class _NativeDelegate extends Sqlite3Delegate<Database> {
     await super.close();
 
     if (closeUnderlyingWhenClosed) {
-      try {
-        tracker.markClosed(database);
-      } on SqliteException {
-        // ignore
+      if (!tracker.isDisposed) {
+        try {
+          tracker.markClosed(database);
+        } on SqliteException {
+          // ignore
+        }
       }
 
       database.dispose();

drift/lib/src/sqlite3/database_tracker.dart

@@ -23,6 +23,10 @@ final DatabaseTracker tracker = DatabaseTracker();
 /// this is necessary.
 class DatabaseTracker {
   final Database _db;
+  bool _isDisposed = false;
+
+  /// Whether this [DatabaseTracker] has been disposed.
+  bool get isDisposed => _isDisposed;
 
   /// Creates a new tracker with necessary tables.
   DatabaseTracker()
@@ -38,24 +42,35 @@ CREATE TABLE IF NOT EXISTS open_connections(
     ''');
   }
 
-  /// Tracks the [openedDb]. The [path] argument can be used to track the path
-  /// of that database, if it's bound to a file.
+  /// Tracks the [openedDb]. The [path] argument can be used to track
+  /// the path of that database, if it's bound to a file.
+  ///
+  /// Throws a [StateError] if this tracker has already been disposed.
   void markOpened(String path, Database openedDb) {
+    _checkIfDisposed();
+
     final stmt = _db.prepare('INSERT INTO open_connections VALUES (?, ?)');
     stmt.execute([openedDb.handle.address, path]);
     stmt.dispose();
   }
 
   /// Marks the database [db] as closed.
+  ///
+  /// Throws a [StateError] if this tracker has already been disposed.
   void markClosed(Database db) {
+    _checkIfDisposed();
+
     final ptr = db.handle.address;
     _db.execute('DELETE FROM open_connections WHERE database_pointer = $ptr');
   }
 
-  /// Closes tracked database connections.
+  /// Closes all tracked database connections that are still open.
+  ///
+  /// Throws a [StateError] if this tracker has already been disposed.
   void closeExisting() {
-    _db.execute('BEGIN;');
+    _checkIfDisposed();
 
+    _db.execute('BEGIN;');
     try {
       final results =
           _db.select('SELECT database_pointer FROM open_connections');
@@ -70,4 +85,30 @@ CREATE TABLE IF NOT EXISTS open_connections(
       _db.execute('COMMIT;');
     }
   }
+
+  /// Releases all open database handles managed by this tracker and
+  /// closes the internal in-memory database.
+  ///
+  /// After calling this method, this instance should no longer be used.
+  /// Any further calls to public methods will throw a [StateError].
+  void dispose() {
+    if (_isDisposed) {
+      return;
+    }
+
+    // Safely close any tracked connections
+    closeExisting();
+
+    _db.dispose();
+    _isDisposed = true;
+  }
+
+  /// Checks if this tracker has been disposed and throws a [StateError] if so.
+  void _checkIfDisposed() {
+    if (_isDisposed) {
+      throw StateError(
+        'DatabaseTracker has already been disposed and can no longer be used.',
+      );
+    }
+  }
 }

drift/test/database/database_tracker_test.dart

@@ -0,0 +1,63 @@
+import 'package:test/test.dart';
+import 'package:sqlite3/sqlite3.dart';
+import 'package:drift/src/sqlite3/database_tracker.dart';
+
+void main() {
+  late DatabaseTracker tracker;
+
+  setUp(() {
+    tracker = DatabaseTracker();
+  });
+
+  tearDown(() {
+    tracker.dispose();
+  });
+
+  test('tracks and closes existing database connections', () {
+    // Open two in-memory SQLite databases.
+    final db1 = sqlite3.openInMemory();
+    final db2 = sqlite3.openInMemory();
+
+    // Register each database with the tracker.
+    tracker.markOpened('db1_path', db1);
+    tracker.markOpened('db2_path', db2);
+
+    // Use the tracker to close all tracked connections.
+    tracker.closeExisting();
+
+    // After closing, further queries should throw an error.
+    expect(
+      () => db1.execute('INSERT INTO test1 (id) VALUES (1)'),
+      throwsA(anything),
+    );
+    expect(
+      () => db2.execute('INSERT INTO test2 (id) VALUES (2)'),
+      throwsA(anything),
+    );
+  });
+
+  test('throws StateError after disposal', () {
+    // Dispose immediately
+    tracker.dispose();
+
+    // Any usage of the tracker after dispose should throw a StateError.
+    expect(
+      () => tracker.markOpened('test', sqlite3.openInMemory()),
+      throwsStateError,
+    );
+    expect(() => tracker.closeExisting(), throwsStateError);
+  });
+
+  test('multiple calls to dispose are safe', () {
+    // Dispose can be called multiple times without throwing errors.
+    expect(() => tracker.dispose(), returnsNormally);
+    expect(() => tracker.dispose(), returnsNormally);
+  });
+
+  test('isDisposed reflects tracker state', () {
+    expect(tracker.isDisposed, isFalse);
+
+    tracker.dispose();
+    expect(tracker.isDisposed, isTrue);
+  });
+}