Merge branch 'development'

Author: groue

CHANGELOG.md

@@ -7,6 +7,7 @@ GRDB adheres to [Semantic Versioning](https://semver.org/), with one exception:
 
 #### 5.x Releases
 
+- `5.20.x` Releases - [5.20.0](#5200)
 - `5.19.x` Releases - [5.19.0](#5190)
 - `5.18.x` Releases - [5.18.0](#5180)
 - `5.17.x` Releases - [5.17.0](#5170)
@@ -86,6 +87,17 @@ GRDB adheres to [Semantic Versioning](https://semver.org/), with one exception:
 
 ---
 
+## 5.20.0
+
+Released February 1, 2022 • [diff](https://github.com/groue/GRDB.swift/compare/v5.19.0...v5.20.0)
+
+- **Fixed**: Fixed a bug of `including(all:)` for composite foreign keys and limited requests.
+- **Fixed**: [#1162](https://github.com/groue/GRDB.swift/pull/1162) by [@groue](https://github.com/groue): Fix truncate optimization handling.
+- **New**: [#1160](https://github.com/groue/GRDB.swift/pull/1160) by [@groue](https://github.com/groue): Hide statement arguments by default.
+- **New**: [#1161](https://github.com/groue/GRDB.swift/pull/1160) by [@groue](https://github.com/groue): Target DispatchQueue for non-read-only database connections.
+- **Documentation Update**: The [Database Configuration](README.md#database-configuration) chapter explains how to opt in for public statement arguments in DEBUG builds.
+
+
 ## 5.19.0
 
 Released January 19, 2022 • [diff](https://github.com/groue/GRDB.swift/compare/v5.18.0...v5.19.0)

Documentation/Concurrency.md

@@ -469,7 +469,7 @@ In the illustration below, the striped band shows the delay needed for the readi
 let snapshot = try dbPool.makeSnapshot()
 ```
 
-You can create as many snapshots as you need, regardless of the [maximum number of readers](../README.md#databasepool-configuration) in the pool. A snapshot database connection is closed when the snapshot is deinitialized.
+You can create as many snapshots as you need, regardless of the [maximum number of readers](../README.md#database-configuration) in the pool. A snapshot database connection is closed when the snapshot is deinitialized.
 
 **A snapshot can be used from any thread.** It has the same [synchronous and asynchronous reading methods](#synchronous-and-asynchronous-database-accesses) as database queues and pools:
 

Documentation/FullTextSearch.md

@@ -304,7 +304,7 @@ let pattern = FTS3Pattern(matchingAnyTokenIn: "")  // nil
 let pattern = FTS3Pattern(matchingAnyTokenIn: "*") // nil
 ```
 
-FTS3Pattern are regular [values](../README.md#values). You can use them as query [arguments](http://groue.github.io/GRDB.swift/docs/5.19/Structs/StatementArguments.html):
+FTS3Pattern are regular [values](../README.md#values). You can use them as query [arguments](http://groue.github.io/GRDB.swift/docs/5.20/Structs/StatementArguments.html):
 
 ```swift
 let documents = try Document.fetchAll(db,
@@ -587,7 +587,7 @@ let pattern = FTS5Pattern(matchingAnyTokenIn: "")  // nil
 let pattern = FTS5Pattern(matchingAnyTokenIn: "*") // nil
 ```
 
-FTS5Pattern are regular [values](../README.md#values). You can use them as query [arguments](http://groue.github.io/GRDB.swift/docs/5.19/Structs/StatementArguments.html):
+FTS5Pattern are regular [values](../README.md#values). You can use them as query [arguments](http://groue.github.io/GRDB.swift/docs/5.20/Structs/StatementArguments.html):
 
 ```swift
 let documents = try Document.fetchAll(db,

Documentation/Migrations.md

@@ -77,7 +77,7 @@ try dbQueue.read { db in
 }
 ```
 
-See the [DatabaseMigrator reference](http://groue.github.io/GRDB.swift/docs/5.19/Structs/DatabaseMigrator.html) for more migrator methods.
+See the [DatabaseMigrator reference](http://groue.github.io/GRDB.swift/docs/5.20/Structs/DatabaseMigrator.html) for more migrator methods.
 
 
 ## The `eraseDatabaseOnSchemaChange` Option

GRDB.swift.podspec

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

GRDB/Core/Configuration.swift

@@ -1,5 +1,5 @@
-import Foundation
 import Dispatch
+import Foundation
 
 /// Configuration for a DatabaseQueue or DatabasePool.
 public struct Configuration {
@@ -102,6 +102,52 @@ public struct Configuration {
     /// [**Experimental**](http://github.com/groue/GRDB.swift#what-are-experimental-features)
     public var observesSuspensionNotifications = false
 
+    /// If false (the default), statement arguments are not visible in the
+    /// description of database errors and trace events, preventing sensitive
+    /// information from leaking in unexpected places.
+    ///
+    /// For example:
+    ///
+    ///     // Error: sensitive information is not printed when an error occurs:
+    ///     do {
+    ///         let email = "..." // sensitive information
+    ///         let player = try Player.filter(Column("email") == email).fetchOne(db)
+    ///     } catch {
+    ///         print(error)
+    ///     }
+    ///
+    ///     // Trace: sensitive information is not printed when a statement is traced:
+    ///     db.trace { event in
+    ///         print(event)
+    ///     }
+    ///     let email = "..." // sensitive information
+    ///     let player = try Player.filter(Column("email") == email).fetchOne(db)
+    ///
+    /// For debugging purpose, you can set this flag to true, and get more
+    /// precise database reports. It is your responsibility to prevent sensitive
+    /// information from leaking in unexpected locations, so you should not set
+    /// this flag in release builds (think about GDPR and other
+    /// privacy-related rules):
+    ///
+    ///     var config = Configuration()
+    ///     #if DEBUG
+    ///     // Protect sensitive information by enabling verbose debugging in DEBUG builds only
+    ///     config.publicStatementArguments = true
+    ///     #endif
+    ///
+    ///     // The descriptions of trace events and errors now contain the
+    ///     // sensitive information:
+    ///     db.trace { event in
+    ///         print(event)
+    ///     }
+    ///     do {
+    ///         let email = "..."
+    ///         let player = try Player.filter(Column("email") == email).fetchOne(db)
+    ///     } catch {
+    ///         print(error)
+    ///     }
+    public var publicStatementArguments = false
+    
     // MARK: - Managing SQLite Connections
 
     private var setups: [(Database) throws -> Void] = []
@@ -202,19 +248,29 @@ public struct Configuration {
     /// Default: .default
     public var qos: DispatchQoS = .default
 
-    /// The target queue for all database accesses.
+    /// A target queue for database accesses.
+    ///
+    /// Database connections which are not read-only will prefer
+    /// `writeTargetQueue` instead, if it is not nil.
     ///
-    /// When you use a database pool, make sure the queue is concurrent. If
-    /// it is serial, no concurrent database access can happen, and you may
-    /// experience deadlocks.
+    /// When you use a database pool, make sure this queue is concurrent. This
+    /// is because in a serial dispatch queue, no concurrent database access can
+    /// happen, and you may experience deadlocks.
     ///
     /// If the queue is nil, all database accesses happen in unspecified
-    /// dispatch queues whose quality of service and label are determined by the
-    /// `qos` and `label` Configuration properties.
+    /// dispatch queues whose quality of service is determined by the
+    /// `qos` property.
     ///
     /// Default: nil
     public var targetQueue: DispatchQueue? = nil
 
+    /// The target queue for database connections which are not read-only.
+    ///
+    /// If this queue is nil, writer connections are controlled by `targetQueue`.
+    ///
+    /// Default: nil
+    public var writeTargetQueue: DispatchQueue? = nil
+    
     // MARK: - Factory Configuration
 
     /// Creates a factory configuration
@@ -241,7 +297,15 @@ public struct Configuration {
         (self.label ?? defaultLabel) + (purpose.map { "." + $0 } ?? "")
     }
 
-    func makeDispatchQueue(label: String) -> DispatchQueue {
+    func makeWriterDispatchQueue(label: String) -> DispatchQueue {
+        if let targetQueue = writeTargetQueue ?? targetQueue {
+            return DispatchQueue(label: label, target: targetQueue)
+        } else {
+            return DispatchQueue(label: label, qos: qos)
+        }
+    }
+    
+    func makeReaderDispatchQueue(label: String) -> DispatchQueue {
         if let targetQueue = targetQueue {
             return DispatchQueue(label: label, target: targetQueue)
         } else {

GRDB/Core/Database+Statements.swift

@@ -542,21 +542,21 @@ public class SQLStatementCursor: Cursor {
 }
 
 extension Database {
-    /// Returns the authorizer that should be used during statement execution
-    /// (this allows preventing the truncate optimization when there exists a
-    /// transaction observer for row deletion).
+    /// Makes sure statement can be executed, and prepares database observation.
     @usableFromInline
-    func statementWillExecute(_ statement: Statement) throws -> StatementAuthorizer? {
+    func statementWillExecute(_ statement: Statement) throws {
         // Two things must prevent the statement from executing: aborted
         // transactions, and database suspension.
         try checkForAbortedTransaction(sql: statement.sql, arguments: statement.arguments)
         try checkForSuspensionViolation(from: statement)
 
-        if _isRecordingSelectedRegion {
-            _selectedRegion.formUnion(statement.databaseRegion)
+        // Database observation: record what the statement is looking at.
+        if isRecordingSelectedRegion {
+            selectedRegion.formUnion(statement.databaseRegion)
         }
 
-        return observationBroker.statementWillExecute(statement)
+        // Database observation: prepare transaction observers.
+        observationBroker.statementWillExecute(statement)
     }
 
     /// May throw a cancelled commit error, if a transaction observer cancels
@@ -589,7 +589,8 @@ extension Database {
             resultCode: resultCode,
             message: lastErrorMessage,
             sql: statement.sql,
-            arguments: statement.arguments)
+            arguments: statement.arguments,
+            publicStatementArguments: configuration.publicStatementArguments)
     }
 }
 
@@ -639,4 +640,8 @@ struct StatementCache {
     mutating func remove(_ statement: Statement) {
         statements.removeFirst { $0.value === statement }
     }
+    
+    mutating func removeAll(where shouldBeRemoved: (Statement) -> Bool) {
+        statements = statements.filter { (_, statement) in !shouldBeRemoved(statement) }
+    }
 }