Add back lockTimeout; Use new methods.

Author: rkistner

.github/workflows/test.yaml

@@ -17,7 +17,9 @@ jobs:
       - name: Check formatting
         run: dart format --output=none --set-exit-if-changed .
       - name: Lint
-        run: dart analyze
+        run: dart analyze lib test example
+      - name: Test Fixes
+        run: dart fix --compare-to-golden test_fixes
       - name: Publish dry-run
         run: dart pub publish --dry-run
       - name: Check publish score

example/basic_example.dart

@@ -28,7 +28,7 @@ void main() async {
   // Combine multiple statements into a single write transaction for:
   // 1. Atomic persistence (all updates are either applied or rolled back).
   // 2. Improved throughput.
-  await db.writeTransaction((tx) async {
+  await db.transaction((tx) async {
     await tx.execute('INSERT INTO test_data(data) values(?)', ['Test3']);
     await tx.execute('INSERT INTO test_data(data) values(?)', ['Test4']);
   });

lib/fix_data.yaml

@@ -0,0 +1,55 @@
+# This provides automatic fixes of deprecations using `dart fix`.
+# See: https://github.com/flutter/flutter/wiki/Data-driven-Fixes
+version: 1
+transforms:
+  - title: 'Rename writeLock to lock'
+    date: 2024-04-02
+    element:
+      uris: ['src/sqlite_connection.dart']
+      method: 'writeLock'
+      inClass: 'SqliteConnection'
+    changes:
+      - kind: 'rename'
+        newName: 'lock'
+  - title: 'Rename writeTransaction to transaction'
+    date: 2024-04-02
+    element:
+      uris: ['src/sqlite_connection.dart']
+      method: 'writeTransaction'
+      inClass: 'SqliteConnection'
+    changes:
+      - kind: 'rename'
+        newName: 'transaction'
+  - title: 'Rename writeLock to lock'
+    date: 2024-04-02
+    element:
+      uris: ['src/sqlite_database.dart']
+      method: 'writeLock'
+      inClass: 'SqliteDatabase'
+    changes:
+      - kind: 'rename'
+        newName: 'lock'
+  - title: 'Rename writeTransaction to transaction'
+    date: 2024-04-02
+    element:
+      uris: ['src/sqlite_database.dart']
+      method: 'writeTransaction'
+      inClass: 'SqliteDatabase'
+    changes:
+      - kind: 'rename'
+        newName: 'transaction'
+  - title: 'Rename readTransaction to transaction'
+    date: 2024-04-02
+    element:
+      uris: ['src/sqlite_database.dart']
+      method: 'readTransaction'
+      inClass: 'SqliteDatabase'
+    changes:
+      - kind: 'addParameter'
+        index: 1
+        name: 'readOnly'
+        style: required_named
+        argumentValue:
+          expression: 'true'
+      - kind: 'rename'
+        newName: 'transaction'

lib/src/connection_pool.dart

@@ -10,7 +10,7 @@ import 'update_notification.dart';
 
 /// A connection pool with a single write connection and multiple read connections.
 class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
-  SqliteConnection? _writeConnection;
+  SqliteConnectionImpl? _writeConnection;
 
   final List<SqliteConnectionImpl> _readConnections = [];
 
@@ -42,7 +42,7 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
   SqliteConnectionPool(this._factory,
       {this.updates,
       this.maxReaders = 5,
-      SqliteConnection? writeConnection,
+      SqliteConnectionImpl? writeConnection,
       this.debugName,
       required this.mutex,
       required SerializedPortClient upstreamPort})
@@ -72,7 +72,7 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
           _readConnections.remove(connection);
         }
         try {
-          return await connection.readLock((ctx) async {
+          return await connection.lock((ctx) async {
             if (haveLock) {
               // Already have a different lock - release this one.
               return false;
@@ -91,7 +91,10 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
             }
 
             return true;
-          }, lockTimeout: lockTimeout, debugContext: debugContext);
+          },
+              lockTimeout: lockTimeout,
+              readOnly: true,
+              debugContext: debugContext);
         } on TimeoutException {
           return false;
         }
@@ -117,6 +120,12 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
   @override
   Future<T> writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) {
+    return _writeLock(callback,
+        lockTimeout: lockTimeout, debugContext: debugContext, global: true);
+  }
+
+  Future<T> _writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
+      {Duration? lockTimeout, String? debugContext, required bool global}) {
     if (closed) {
       throw AssertionError('Closed');
     }
@@ -132,10 +141,28 @@ class SqliteConnectionPool with SqliteQueries implements SqliteConnection {
         readOnly: false,
         openFactory: _factory);
     return _runZoned(() {
+      if (global) {
+        // ignore: deprecated_member_use_from_same_package
+        return _writeConnection!.writeLock(callback,
+            lockTimeout: lockTimeout, debugContext: debugContext);
+      } else {
+        return _writeConnection!.lock(callback,
+            lockTimeout: lockTimeout, debugContext: debugContext);
+      }
+    }, debugContext: debugContext ?? 'execute()');
+  }
+
+  @override
+  Future<T> lock<T>(Future<T> Function(SqliteWriteContext tx) callback,
+      {bool? readOnly, Duration? lockTimeout, String? debugContext}) {
+    if (readOnly == true) {
       // ignore: deprecated_member_use_from_same_package
-      return _writeConnection!.writeLock(callback,
+      return readLock((ctx) => callback(ctx as SqliteWriteContext),
           lockTimeout: lockTimeout, debugContext: debugContext);
-    }, debugContext: debugContext ?? 'execute()');
+    } else {
+      return _writeLock(callback,
+          lockTimeout: lockTimeout, debugContext: debugContext, global: false);
+    }
   }
 
   /// The [Mutex] on individual connections do already error in recursive locks.

lib/src/sqlite_connection.dart

@@ -82,16 +82,18 @@ abstract class SqliteConnection extends SqliteWriteContext {
   /// Statements within the transaction must be done on the provided
   /// [SqliteWriteContext] - attempting statements on the [SqliteConnection]
   /// instance will error.
+  ///
+  /// [lockTimeout] only controls the timeout for locking the connection.
+  /// Timeout for database-level locks can be configured on [SqliteOpenOptions].
   Future<T> transaction<T>(Future<T> Function(SqliteWriteContext tx) callback,
-      {bool? readOnly});
+      {bool? readOnly, Duration? lockTimeout});
 
   /// Open a read-only transaction.
   ///
   /// Statements within the transaction must be done on the provided
   /// [SqliteReadContext] - attempting statements on the [SqliteConnection]
   /// instance will error.
-  @Deprecated(
-      'Use [transaction(callback)] instead, and set lockTimeout on [SqliteOpenOptions].')
+  @Deprecated('Use [transaction(callback)] instead.')
   Future<T> readTransaction<T>(
       Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout});
@@ -104,8 +106,7 @@ abstract class SqliteConnection extends SqliteWriteContext {
   /// Statements within the transaction must be done on the provided
   /// [SqliteWriteContext] - attempting statements on the [SqliteConnection]
   /// instance will error.
-  @Deprecated(
-      'Use [transaction(callback)] instead, and set lockTimeout on [SqliteOpenOptions].')
+  @Deprecated('Use [transaction(callback)] instead.')
   Future<T> writeTransaction<T>(
       Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout});
@@ -122,14 +123,14 @@ abstract class SqliteConnection extends SqliteWriteContext {
   /// Takes a read lock on this connection, without starting a transaction.
   ///
   /// This is a low-level API. In most cases, [transaction] should be used instead.
-  @Deprecated('Use [lock] instead, and set lockTimeout on [SqliteOpenOptions].')
+  @Deprecated('Use [lock] instead.')
   Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout, String? debugContext});
 
   /// Takes a global write lock, without starting a transaction.
   ///
   /// This is a low-level API. In most cases, [transaction] should be used instead.
-  @Deprecated('Use [lock] instead, and set lockTimeout on [SqliteOpenOptions].')
+  @Deprecated('Use [lock] instead.')
   Future<T> writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout, String? debugContext});
 
@@ -142,7 +143,7 @@ abstract class SqliteConnection extends SqliteWriteContext {
   ///
   /// Any direct query methods such as [getAll] or [execute] uses [lock] internally.
   Future<T> lock<T>(Future<T> Function(SqliteWriteContext tx) callback,
-      {bool? readOnly, String? debugContext});
+      {bool? readOnly, Duration? lockTimeout, String? debugContext});
 
   Future<void> close();
 

lib/src/sqlite_connection_impl.dart

@@ -106,8 +106,8 @@ class SqliteConnectionImpl with SqliteQueries implements SqliteConnection {
   }
 
   @override
-  Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
-      {Duration? lockTimeout, String? debugContext}) async {
+  Future<T> lock<T>(Future<T> Function(SqliteWriteContext tx) callback,
+      {bool? readOnly, Duration? lockTimeout, String? debugContext}) async {
     // Private lock to synchronize this with other statements on the same connection,
     // to ensure that transactions aren't interleaved.
     return _connectionMutex.lock(() async {
@@ -120,6 +120,12 @@ class SqliteConnectionImpl with SqliteQueries implements SqliteConnection {
     }, timeout: lockTimeout);
   }
 
+  @override
+  Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
+      {Duration? lockTimeout, String? debugContext}) async {
+    return lock(callback, lockTimeout: lockTimeout, debugContext: debugContext);
+  }
+
   @override
   Future<T> writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) async {

lib/src/sqlite_database.dart

@@ -199,10 +199,12 @@ class SqliteDatabase with SqliteQueries implements SqliteConnection {
   /// Changes from any write transaction are not visible to read transactions
   /// started before it.
   @override
+  @Deprecated('Use [transaction] instead.')
   Future<T> readTransaction<T>(
       Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout}) {
-    return _pool.readTransaction(callback, lockTimeout: lockTimeout);
+    return _pool.transaction(callback,
+        readOnly: true, lockTimeout: lockTimeout);
   }
 
   /// Open a read-write transaction.
@@ -213,20 +215,23 @@ class SqliteDatabase with SqliteQueries implements SqliteConnection {
   /// The write transaction is automatically committed when the callback finishes,
   /// or rolled back on any error.
   @override
+  @Deprecated('Use [transaction] instead.')
   Future<T> writeTransaction<T>(
       Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout}) {
-    return _pool.writeTransaction(callback, lockTimeout: lockTimeout);
+    return _pool.transaction(callback, lockTimeout: lockTimeout);
   }
 
   @override
+  @Deprecated('Use [lock] instead.')
   Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) {
-    return _pool.readLock(callback,
-        lockTimeout: lockTimeout, debugContext: debugContext);
+    return _pool.lock(callback,
+        readOnly: true, lockTimeout: lockTimeout, debugContext: debugContext);
   }
 
   @override
+  @Deprecated('Use [lock] instead.')
   Future<T> writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) {
     return _pool.writeLock(callback,

lib/src/sqlite_queries.dart

@@ -144,26 +144,28 @@ mixin SqliteQueries implements SqliteWriteContext, SqliteConnection {
 
   @override
   Future<T> lock<T>(Future<T> Function(SqliteWriteContext tx) callback,
-      {bool? readOnly, String? debugContext}) {
+      {bool? readOnly, Duration? lockTimeout, String? debugContext}) {
     if (readOnly == true) {
       // ignore: deprecated_member_use_from_same_package
       return readLock((ctx) => callback(ctx as SqliteWriteContext),
-          debugContext: debugContext);
+          lockTimeout: lockTimeout, debugContext: debugContext);
     } else {
       // ignore: deprecated_member_use_from_same_package
-      return writeLock(callback, debugContext: debugContext);
+      return writeLock(callback,
+          lockTimeout: lockTimeout, debugContext: debugContext);
     }
   }
 
   @override
   Future<T> transaction<T>(Future<T> Function(SqliteWriteContext tx) callback,
-      {bool? readOnly}) {
+      {bool? readOnly, Duration? lockTimeout}) {
     if (readOnly == true) {
       // ignore: deprecated_member_use_from_same_package
-      return readTransaction((ctx) => callback(ctx as SqliteWriteContext));
+      return readTransaction((ctx) => callback(ctx as SqliteWriteContext),
+          lockTimeout: lockTimeout);
     } else {
       // ignore: deprecated_member_use_from_same_package
-      return writeTransaction(callback);
+      return writeTransaction(callback, lockTimeout: lockTimeout);
     }
   }
 }

scripts/benchmark.dart

@@ -25,7 +25,7 @@ class SqliteBenchmark {
 List<SqliteBenchmark> benchmarks = [
   SqliteBenchmark('Insert: JSON1',
       (SqliteDatabase db, List<List<String>> parameters) async {
-    await db.writeTransaction((tx) async {
+    await db.transaction((tx) async {
       for (var i = 0; i < parameters.length; i += 5000) {
         var sublist = parameters.sublist(i, min(parameters.length, i + 5000));
         await tx.execute(
@@ -37,14 +37,14 @@ List<SqliteBenchmark> benchmarks = [
   }, maxBatchSize: 20000),
   SqliteBenchmark('Read: JSON1',
       (SqliteDatabase db, List<List<String>> parameters) async {
-    await db.readTransaction((tx) async {
+    await db.transaction((tx) async {
       for (var i = 0; i < parameters.length; i += 10000) {
         var sublist = List.generate(10000, (index) => index);
         await tx.getAll(
             'SELECT name, email FROM customers WHERE id IN (SELECT e.value FROM json_each(?) e)',
             [jsonEncode(sublist)]);
       }
-    });
+    }, readOnly: true);
   }, maxBatchSize: 200000, enabled: false),
   SqliteBenchmark('lock in isolate',
       (SqliteDatabase db, List<List<String>> parameters) async {
@@ -61,13 +61,14 @@ List<SqliteBenchmark> benchmarks = [
   SqliteBenchmark('Write lock',
       (SqliteDatabase db, List<List<String>> parameters) async {
     for (var _ in parameters) {
+      // ignore: deprecated_member_use_from_same_package
       await db.writeLock((tx) async {});
     }
   }, maxBatchSize: 5000, enabled: false),
   SqliteBenchmark('Read lock',
       (SqliteDatabase db, List<List<String>> parameters) async {
     for (var _ in parameters) {
-      await db.readLock((tx) async {});
+      await db.lock((tx) async {}, readOnly: true);
     }
   }, maxBatchSize: 5000, enabled: false),
   SqliteBenchmark('Insert: Direct',
@@ -79,7 +80,7 @@ List<SqliteBenchmark> benchmarks = [
   }, maxBatchSize: 500),
   SqliteBenchmark('Insert: writeTransaction',
       (SqliteDatabase db, List<List<String>> parameters) async {
-    await db.writeTransaction((tx) async {
+    await db.transaction((tx) async {
       for (var params in parameters) {
         await tx.execute(
             'INSERT INTO customers(name, email) VALUES(?, ?)', params);
@@ -110,7 +111,7 @@ List<SqliteBenchmark> benchmarks = [
   }, maxBatchSize: 2000),
   SqliteBenchmark('Insert: writeTransaction no await',
       (SqliteDatabase db, List<List<String>> parameters) async {
-    await db.writeTransaction((tx) async {
+    await db.transaction((tx) async {
       for (var params in parameters) {
         tx.execute('INSERT INTO customers(name, email) VALUES(?, ?)', params);
       }
@@ -139,7 +140,7 @@ List<SqliteBenchmark> benchmarks = [
   }),
   SqliteBenchmark('Insert: executeBatch',
       (SqliteDatabase db, List<List<String>> parameters) async {
-    await db.writeTransaction((tx) async {
+    await db.transaction((tx) async {
       await tx.executeBatch(
           'INSERT INTO customers(name, email) VALUES(?, ?)', parameters);
     });
@@ -167,7 +168,7 @@ void main() async {
       20000, (index) => ['Test user $index', 'user$index@example.org']);
 
   createTables(SqliteDatabase db) async {
-    await db.writeTransaction((tx) async {
+    await db.transaction((tx) async {
       await tx.execute('DROP TABLE IF EXISTS customers');
       await tx.execute(
           'CREATE TABLE customers(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, email TEXT)');