Merge remote-tracking branch 'origin/prepare-release' into get_all_connections

Author: davidmartos96

CHANGELOG.md

@@ -3,6 +3,27 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-05-22
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`sqlite_async` - `v0.11.5`](#sqlite_async---v0115)
+
+---
+
+#### `sqlite_async` - `v0.11.5`
+
+- Allow profiling queries. Queries are profiled by default in debug and profile builds, the runtime
+  for queries is added to profiling timelines under the `sqlite_async` tag.
+- Fix cancelling `watch()` queries sometimes taking longer than necessary.
+- Fix web databases not respecting lock timeouts.
+
 ## 2024-11-06
 
 ### Changes

packages/drift_sqlite_async/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.2
+
+- Fix write detection when using UPDATE/INSERT/DELETE with RETURNING in raw queries.
+
 ## 0.2.1
 
 - Fix lints.

packages/drift_sqlite_async/lib/src/executor.dart

@@ -8,7 +8,8 @@ import 'package:sqlite_async/sqlite_async.dart';
 // Ends with " RETURNING *", or starts with insert/update/delete.
 // Drift-generated queries will always have the RETURNING *.
 // The INSERT/UPDATE/DELETE check is for custom queries, and is not exhaustive.
-final _returningCheck = RegExp(r'( RETURNING \*;?$)|(^(INSERT|UPDATE|DELETE))',
+final _returningCheck = RegExp(
+    r'( RETURNING \*;?\s*$)|(^\s*(INSERT|UPDATE|DELETE))',
     caseSensitive: false);
 
 class _SqliteAsyncDelegate extends _SqliteAsyncQueryDelegate

packages/drift_sqlite_async/pubspec.yaml

@@ -1,5 +1,5 @@
 name: drift_sqlite_async
-version: 0.2.1
+version: 0.2.2
 homepage: https://github.com/powersync-ja/sqlite_async.dart
 repository: https://github.com/powersync-ja/sqlite_async.dart
 description: Use Drift with a sqlite_async database, allowing both to be used in the same application.

packages/drift_sqlite_async/test/basic_test.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 
 import 'package:drift/drift.dart';
 import 'package:drift_sqlite_async/drift_sqlite_async.dart';
+import 'package:sqlite3/common.dart';
 import 'package:sqlite_async/sqlite_async.dart';
 import 'package:test/test.dart';
 
@@ -219,5 +220,29 @@ void main() {
               .data,
           equals({'count': 1}));
     });
+
+    test('cannot update database with read', () async {
+      await expectLater(() => dbu.customSelect('''
+-- trick to circumvent regex detecting writes
+INSERT INTO test_data(description) VALUES('test data');
+''').get(), throwsA(isA<SqliteException>()));
+    });
+
+    test('allows spaces after returning', () async {
+      // This tests that the statement is forwarded to the write connection
+      // despite using customSelect(). If it wasn't, we'd get an error about
+      // the database being read-only.
+      final row = await dbu.customSelect(
+          'INSERT INTO test_data(description) VALUES(?) RETURNING *   ',
+          variables: [Variable('Test Data')]).getSingle();
+      expect(row.data['description'], equals('Test Data'));
+    });
+
+    test('allows spaces before insert', () async {
+      final row = await dbu.customSelect(
+          '  INSERT INTO test_data(description) VALUES(?)   ',
+          variables: [Variable('Test Data')]).get();
+      expect(row, isEmpty);
+    });
   });
 }

packages/drift_sqlite_async/test/db_test.dart

@@ -106,5 +106,16 @@ void main() {
             '[]'
           ]));
     });
+
+    test('delete returns affected rows', () async {
+      for (var i = 0; i < 10; i++) {
+        await dbu
+            .into(dbu.todoItems)
+            .insert(TodoItemsCompanion.insert(description: 'desc $i'));
+      }
+
+      final deleted = await dbu.delete(dbu.todoItems).go();
+      expect(deleted, 10);
+    });
   });
 }

packages/sqlite_async/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.11.5
+
+- Allow profiling queries. Queries are profiled by default in debug and profile builds, the runtime
+  for queries is added to profiling timelines under the `sqlite_async` tag.
+- Fix cancelling `watch()` queries sometimes taking longer than necessary. 
+- Fix web databases not respecting lock timeouts.
+
 ## 0.11.4
 
 - Add `SqliteConnection.synchronousWrapper` and `SqliteDatabase.singleConnection`.

packages/sqlite_async/lib/src/common/connection/sync_sqlite_connection.dart

@@ -1,8 +1,12 @@
+import 'dart:developer';
+
 import 'package:sqlite3/common.dart';
 import 'package:sqlite_async/src/common/mutex.dart';
 import 'package:sqlite_async/src/sqlite_connection.dart';
+import 'package:sqlite_async/src/sqlite_options.dart';
 import 'package:sqlite_async/src/sqlite_queries.dart';
 import 'package:sqlite_async/src/update_notification.dart';
+import 'package:sqlite_async/src/utils/profiler.dart';
 
 /// A simple "synchronous" connection which provides the async SqliteConnection
 /// implementation using a synchronous SQLite connection
@@ -14,7 +18,15 @@ class SyncSqliteConnection extends SqliteConnection with SqliteQueries {
 
   bool _closed = false;
 
-  SyncSqliteConnection(this.db, Mutex m) {
+  /// Whether queries should be added to the `dart:developer` timeline.
+  ///
+  /// This is enabled by default outside of release builds, see
+  /// [SqliteOptions.profileQueries] for details.
+  final bool profileQueries;
+
+  SyncSqliteConnection(this.db, Mutex m, {bool? profileQueries})
+      : profileQueries =
+            profileQueries ?? const SqliteOptions().profileQueries {
     mutex = m.open();
     updates = db.updates.map(
       (event) {
@@ -26,15 +38,31 @@ class SyncSqliteConnection extends SqliteConnection with SqliteQueries {
   @override
   Future<T> readLock<T>(Future<T> Function(SqliteReadContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) {
-    return mutex.lock(() => callback(SyncReadContext(db)),
-        timeout: lockTimeout);
+    final task = profileQueries ? TimelineTask() : null;
+    task?.start('${profilerPrefix}mutex_lock');
+
+    return mutex.lock(
+      () {
+        task?.finish();
+        return callback(SyncReadContext(db, parent: task));
+      },
+      timeout: lockTimeout,
+    );
   }
 
   @override
   Future<T> writeLock<T>(Future<T> Function(SqliteWriteContext tx) callback,
       {Duration? lockTimeout, String? debugContext}) {
-    return mutex.lock(() => callback(SyncWriteContext(db)),
-        timeout: lockTimeout);
+    final task = profileQueries ? TimelineTask() : null;
+    task?.start('${profilerPrefix}mutex_lock');
+
+    return mutex.lock(
+      () {
+        task?.finish();
+        return callback(SyncWriteContext(db, parent: task));
+      },
+      timeout: lockTimeout,
+    );
   }
 
   @override
@@ -53,9 +81,12 @@ class SyncSqliteConnection extends SqliteConnection with SqliteQueries {
 }
 
 class SyncReadContext implements SqliteReadContext {
+  final TimelineTask? task;
+
   CommonDatabase db;
 
-  SyncReadContext(this.db);
+  SyncReadContext(this.db, {TimelineTask? parent})
+      : task = TimelineTask(parent: parent);
 
   @override
   Future<T> computeWithDatabase<T>(
@@ -65,13 +96,23 @@ class SyncReadContext implements SqliteReadContext {
 
   @override
   Future<Row> get(String sql, [List<Object?> parameters = const []]) async {
-    return db.select(sql, parameters).first;
+    return task.timeSync(
+      'get',
+      () => db.select(sql, parameters).first,
+      sql: sql,
+      parameters: parameters,
+    );
   }
 
   @override
   Future<ResultSet> getAll(String sql,
       [List<Object?> parameters = const []]) async {
-    return db.select(sql, parameters);
+    return task.timeSync(
+      'getAll',
+      () => db.select(sql, parameters),
+      sql: sql,
+      parameters: parameters,
+    );
   }
 
   @override
@@ -91,26 +132,32 @@ class SyncReadContext implements SqliteReadContext {
 }
 
 class SyncWriteContext extends SyncReadContext implements SqliteWriteContext {
-  SyncWriteContext(super.db);
+  SyncWriteContext(super.db, {super.parent});
 
   @override
   Future<ResultSet> execute(String sql,
       [List<Object?> parameters = const []]) async {
-    return db.select(sql, parameters);
+    return task.timeSync(
+      'execute',
+      () => db.select(sql, parameters),
+      sql: sql,
+      parameters: parameters,
+    );
   }
 
   @override
   Future<void> executeBatch(
       String sql, List<List<Object?>> parameterSets) async {
-    return computeWithDatabase((db) async {
+    task.timeSync('executeBatch', () {
       final statement = db.prepare(sql, checkNoTail: true);
       try {
         for (var parameters in parameterSets) {
-          statement.execute(parameters);
+          task.timeSync('iteration', () => statement.execute(parameters),
+              parameters: parameters);
         }
       } finally {
         statement.dispose();
       }
-    });
+    }, sql: sql);
   }
 }