Merge branch 'development'

Author: groue

CHANGELOG.md

@@ -7,6 +7,7 @@ GRDB adheres to [Semantic Versioning](https://semver.org/), with one exception:
 
 #### 7.x Releases
 
+- `7.1.x` Releases - [7.1.0](#710)
 - `7.0.x` Releases - [7.0.0](#700)
 - `7.0.0` Betas - [7.0.0-beta](#700-beta) - [7.0.0-beta.2](#700-beta2) - [7.0.0-beta.3](#700-beta3) - [7.0.0-beta.4](#700-beta4) - [7.0.0-beta.5](#700-beta5) - [7.0.0-beta.6](#700-beta6) - [7.0.0-beta.7](#700-beta7)
 
@@ -132,6 +133,14 @@ GRDB adheres to [Semantic Versioning](https://semver.org/), with one exception:
 
 ---
 
+## 7.1.0
+
+Released February 5, 2025
+
+- **New**: Expose `sqlite3_libversion_number` as `Database.sqliteLibVersionNumber` by [@groue](https://github.com/groue) in [#1713](https://github.com/groue/GRDB.swift/pull/1713)
+- **Fixed**: DatabaseQueue restores its read/write abilities when an async read-only database access is cancelled by [@groue](https://github.com/groue) in [#1716](https://github.com/groue/GRDB.swift/pull/1716)
+- **New**: Allow RxGRDB to compile without warning by [@groue](https://github.com/groue) in [#1717](https://github.com/groue/GRDB.swift/pull/1717)
+
 ## 7.0.0
 
 Released January 26, 2025

GRDB.swift.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name     = 'GRDB.swift'
-  s.version  = '7.0.0'
+  s.version  = '7.1.0'
 
   s.license  = { :type => 'MIT', :file => 'LICENSE' }
   s.summary  = 'A toolkit for SQLite databases, with a focus on application development.'

GRDB/Core/Database.swift

@@ -1288,6 +1288,12 @@ public final class Database: CustomStringConvertible, CustomDebugStringConvertib
             return
         }
 
+        // Suspension should not prevent adjusting the read-only mode.
+        // See <https://github.com/groue/GRDB.swift/issues/1715>.
+        if statement.isQueryOnlyPragma {
+            return
+        }
+        
         // How should we interrupt the statement?
         enum Interrupt {
             case abort  // Rollback and throw SQLITE_ABORT

GRDB/Core/DatabaseRegionObservation.swift

@@ -83,6 +83,7 @@ extension DatabaseRegionObservation {
     /// - parameter onChange: The closure to execute when a transaction has
     ///   modified the observed region.
     /// - returns: A DatabaseCancellable that can stop the observation.
+    @preconcurrency // For RxGRDB, see <https://github.com/RxSwiftCommunity/RxGRDB/issues/72#issuecomment-2631125658>
     public func start(
         in writer: any DatabaseWriter,
         onError: @escaping @Sendable (Error) -> Void,

GRDB/Core/Statement.swift

@@ -92,6 +92,9 @@ public final class Statement {
     /// The effects on the database (reported by `sqlite3_set_authorizer`).
     private(set) var authorizerEventKinds: [DatabaseEventKind] = []
 
+    /// If true, the statement executes is a `PRAGMA QUERY_ONLY` statement.
+    private(set) var isQueryOnlyPragma = false
+    
     /// A boolean value indicating if the prepared statement makes no direct
     /// changes to the content of the database file.
     ///
@@ -160,6 +163,7 @@ public final class Statement {
         self.invalidatesDatabaseSchemaCache = authorizer.invalidatesDatabaseSchemaCache
         self.transactionEffect = authorizer.transactionEffect
         self.authorizerEventKinds = authorizer.databaseEventKinds
+        self.isQueryOnlyPragma = authorizer.isQueryOnlyPragma
     }
 
     deinit {

GRDB/Core/StatementAuthorizer.swift

@@ -41,6 +41,9 @@ final class StatementAuthorizer {
     /// savepoint statement.
     var transactionEffect: Statement.TransactionEffect?
 
+    /// If true, the statement executes is a `PRAGMA QUERY_ONLY` statement.
+    var isQueryOnlyPragma = false
+    
     private var isDropStatement = false
 
     init(_ database: Database) {
@@ -67,6 +70,7 @@ final class StatementAuthorizer {
         databaseEventKinds = []
         invalidatesDatabaseSchemaCache = false
         transactionEffect = nil
+        isQueryOnlyPragma = false
         isDropStatement = false
     }
 
@@ -192,6 +196,11 @@ final class StatementAuthorizer {
             }
             return SQLITE_OK
 
+        case SQLITE_PRAGMA:
+            if let cString1 {
+                isQueryOnlyPragma = sqlite3_stricmp(cString1, "query_only") == 0
+            }
+            return SQLITE_OK
         default:
             return SQLITE_OK
         }

README.md

@@ -15,7 +15,7 @@
     <a href="https://github.com/groue/GRDB.swift/actions/workflows/CI.yml"><img alt="CI Status" src="https://github.com/groue/GRDB.swift/actions/workflows/CI.yml/badge.svg?branch=master"></a>
 </p>
 
-**Latest release**: January 26, 2025 • [version 7.0.0](https://github.com/groue/GRDB.swift/tree/v7.0.0) • [CHANGELOG](CHANGELOG.md) • [Migrating From GRDB 6 to GRDB 7](Documentation/GRDB7MigrationGuide.md)
+**Latest release**: February 5, 2025 • [version 7.1.0](https://github.com/groue/GRDB.swift/tree/v7.1.0) • [CHANGELOG](CHANGELOG.md) • [Migrating From GRDB 6 to GRDB 7](Documentation/GRDB7MigrationGuide.md)
 
 **Requirements**: iOS 13.0+ / macOS 10.15+ / tvOS 13.0+ / watchOS 7.0+ &bull; SQLite 3.20.0+ &bull; Swift 6+ / Xcode 16+
 

Support/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>7.0.0</string>
+	<string>7.1.0</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

Tests/GRDBTests/DatabaseWriterTests.swift

@@ -415,6 +415,57 @@ class DatabaseWriterTests : GRDBTestCase {
 
     // MARK: - Task Cancellation
 
+    // Regression test for <https://github.com/groue/GRDB.swift/issues/1715>.
+    func test_write_is_possible_after_read_cancelled_after_database_access() async throws {
+        // When a read access is cancelled, DatabaseQueue needs to execute
+        // `PRAGMA query_only=0` in order to restore the read/write access.
+        //
+        // Here we test that this pragma can run from a cancelled read.
+        //
+        // Small difficulty: some SQLite versions (seen with 3.43.2) execute
+        // the `query_only` pragma at compile time, not only at execution
+        // time (yeah, that's an SQLite bug). The problem of this bug is
+        // that even if the `PRAGMA query_only=0` is not executed due to
+        // Task cancellation, its side effect is still executed when it is
+        // compiled, unintentionally. A cancelled `PRAGMA query_only=0`
+        // still works!
+        //
+        // To avoid this SQLite bug from messing with our test, we perform
+        // two reads: one that compiles and cache `PRAGMA query_only`
+        // statements, and a second read that we cancel. This time the
+        // `PRAGMA query_only=0` triggers its side effect if and only if it
+        // is actually executed (the behavior we are testing).
+        func test(_ dbWriter: some DatabaseWriter) async throws {
+            let semaphore = AsyncSemaphore(value: 0)
+            let cancelledTaskMutex = Mutex<Task<Void, any Error>?>(nil)
+            let task = Task {
+                await semaphore.wait()
+                
+                // First read, not cancelled, so that all `query_only`
+                // pragma statements are compiled (see above).
+                try await dbWriter.read { db in }
+                
+                // Second read, cancelled.
+                try await dbWriter.read { db in
+                    try XCTUnwrap(cancelledTaskMutex.load()).cancel()
+                }
+            }
+            cancelledTaskMutex.store(task)
+            semaphore.signal()
+            // Wait until reads are completed
+            try? await task.value
+            
+            // Write access is restored after read cancellation (no error is thrown)
+            try await dbWriter.write { db in
+                try db.execute(sql: "CREATE TABLE test(a)")
+            }
+        }
+        
+        try await test(makeDatabaseQueue())
+        try await test(makeDatabasePool())
+        try await test(AnyDatabaseWriter(makeDatabaseQueue()))
+    }
+    
     func test_writeWithoutTransaction_is_cancelled_by_Task_cancellation_performed_before_database_access() async throws {
         func test(_ dbWriter: some DatabaseWriter) async throws {
             let semaphore = AsyncSemaphore(value: 0)