Allow iterating after BUSY errors

Author: simolus3

sqlite3/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.3
+
+- Allow iterating over statements after `SQLITE_BUSY` errors.
+
 ## 2.9.2
 
 - Fix a bug introduced in version `2.9.1` where the SQLite framework provided by

sqlite3/lib/src/implementation/statement.dart

@@ -386,7 +386,11 @@ class _ActiveCursorIterator extends IteratingCursor {
     }
 
     // We're at the end of the result set or encountered an exception here.
-    statement._currentCursor = null;
+    if (result != SqlError.SQLITE_BUSY) {
+      // Statements failing with SQLITE_BUSY can be retried in some instances,
+      // so we don't want to detach the cursor.
+      statement._currentCursor = null;
+    }
 
     if (result != SqlError.SQLITE_OK && result != SqlError.SQLITE_DONE) {
       throwException(

sqlite3/pubspec.yaml

@@ -1,6 +1,6 @@
 name: sqlite3
 description: Provides lightweight yet convenient bindings to SQLite by using dart:ffi
-version: 2.9.2
+version: 2.9.3
 homepage: https://github.com/simolus3/sqlite3.dart/tree/main/sqlite3
 issue_tracker: https://github.com/simolus3/sqlite3.dart/issues
 resolution: workspace

sqlite3/test/common/prepared_statement.dart

@@ -564,6 +564,34 @@ void testPreparedStatements(
         throwsSqlError(19, 2067),
       );
     });
+
+    test('recovers from SQLITE_BUSY', () {
+      final vfs = _ErrorInjectingVfs(InMemoryFileSystem(),
+          name: 'test-recover-sqlite-busy');
+      sqlite3.registerVirtualFileSystem(vfs);
+      addTearDown(() => sqlite3.unregisterVirtualFileSystem(vfs));
+
+      var db = sqlite3.open('/db', vfs: vfs.name);
+      addTearDown(() => db.dispose());
+
+      db
+        ..execute('CREATE TABLE foo (bar TEXT) STRICT')
+        ..execute('INSERT INTO foo (bar) VALUES (?)', ['testing'])
+        ..dispose();
+
+      db = db = sqlite3.open('/db', vfs: vfs.name);
+      final stmt = db.prepare('SELECT * FROM foo');
+      final cursor = stmt.selectCursor();
+      vfs.maybeError = () => throw VfsException(SqlError.SQLITE_BUSY);
+
+      expect(() => cursor.moveNext(),
+          throwsSqlError(SqlError.SQLITE_BUSY, SqlError.SQLITE_BUSY));
+      vfs.maybeError = null;
+      expect(cursor.moveNext(), isTrue);
+      expect(cursor.current, {'bar': 'testing'});
+
+      stmt.dispose();
+    });
   });
 }
 
@@ -581,3 +609,111 @@ class _CustomValue implements CustomStatementParameter {
     stmt.statement.sqlite3_bind_int64(index, 42);
   }
 }
+
+final class _ErrorInjectingVfs extends BaseVirtualFileSystem {
+  final VirtualFileSystem _base;
+  void Function()? maybeError;
+
+  _ErrorInjectingVfs(this._base, {required super.name});
+
+  void _op() {
+    maybeError?.call();
+  }
+
+  @override
+  int xAccess(String path, int flags) {
+    _op();
+    return _base.xAccess(path, flags);
+  }
+
+  @override
+  void xDelete(String path, int syncDir) {
+    _op();
+    return _base.xDelete(path, syncDir);
+  }
+
+  @override
+  String xFullPathName(String path) {
+    _op();
+    return _base.xFullPathName(path);
+  }
+
+  @override
+  XOpenResult xOpen(Sqlite3Filename path, int flags) {
+    _op();
+    final inner = _base.xOpen(path, flags);
+    return (
+      outFlags: inner.outFlags,
+      file: _ErrorInjectingFile(this, inner.file)
+    );
+  }
+
+  @override
+  void xSleep(Duration duration) {
+    return _base.xSleep(duration);
+  }
+}
+
+final class _ErrorInjectingFile implements VirtualFileSystemFile {
+  final _ErrorInjectingVfs _vfs;
+  final VirtualFileSystemFile _base;
+
+  _ErrorInjectingFile(this._vfs, this._base);
+
+  @override
+  void xRead(Uint8List target, int fileOffset) {
+    _vfs._op();
+    return _base.xRead(target, fileOffset);
+  }
+
+  @override
+  int xCheckReservedLock() {
+    _vfs._op();
+    return _base.xCheckReservedLock();
+  }
+
+  @override
+  int get xDeviceCharacteristics => _base.xDeviceCharacteristics;
+
+  @override
+  void xClose() {
+    _vfs._op();
+    _base.xClose();
+  }
+
+  @override
+  int xFileSize() {
+    _vfs._op();
+    return _base.xFileSize();
+  }
+
+  @override
+  void xLock(int mode) {
+    _vfs._op();
+    _base.xLock(mode);
+  }
+
+  @override
+  void xSync(int flags) {
+    _vfs._op();
+    _base.xSync(flags);
+  }
+
+  @override
+  void xTruncate(int size) {
+    _vfs._op();
+    _base.xTruncate(size);
+  }
+
+  @override
+  void xUnlock(int mode) {
+    _vfs._op();
+    _base.xUnlock(mode);
+  }
+
+  @override
+  void xWrite(Uint8List buffer, int fileOffset) {
+    _vfs._op();
+    _base.xWrite(buffer, fileOffset);
+  }
+}