Make memory management optional.

Memory management may not be desirable for all
users of GRDB. `DatabasePool.releaseMemory`
creates a barrier which may cause normally fast
readers to block for a long time. If this is not a
desirable tradeoff, the new
`automaticMemoryManagement` flag in
`Configuration` allows you to disable this feature
of GRDB.

Author: george-signal

GRDB/Core/Configuration.swift

@@ -275,7 +275,19 @@ public struct Configuration {
     ///
     /// Default: nil
     public var writeTargetQueue: DispatchQueue? = nil
-    
+
+    /// Sets whether GRDB will release memory when entering the background or
+    /// upon receiving a memory warning in iOS.
+    ///
+    /// Enabling this setting may help keep iOS from terminating your app when
+    /// memory pressure becomes high. However, it can also cause database
+    /// readers to block longer than they normally would.
+    ///
+    /// Default: true
+#if os(iOS)
+    public var automaticMemoryManagement = true
+#endif
+
     // MARK: - Factory Configuration
 
     /// Creates a factory configuration

GRDB/Core/DatabasePool.swift

@@ -103,7 +103,9 @@ public final class DatabasePool: DatabaseWriter {
         // Be a nice iOS citizen, and don't consume too much memory
         // See https://github.com/groue/GRDB.swift/#memory-management
         #if os(iOS)
-        setupMemoryManagement()
+        if configuration.automaticMemoryManagement {
+            setupMemoryManagement()
+        }
         #endif
     }
 
@@ -161,6 +163,17 @@ public final class DatabasePool: DatabaseWriter {
         writer.sync(body)
         readerPool?.forEach { $0.sync(body) }
     }
+
+    var numberOfReaders: Int {
+        guard let readerPool = readerPool else {
+            return 0
+        }
+        var count = 0
+        readerPool.forEach { _ in
+            count += 1
+        }
+        return count
+    }
 }
 
 #if swift(>=5.6) && canImport(_Concurrency)

GRDB/Core/DatabaseQueue.swift

@@ -43,7 +43,9 @@ public final class DatabaseQueue: DatabaseWriter {
         // Be a nice iOS citizen, and don't consume too much memory
         // See https://github.com/groue/GRDB.swift/#memory-management
         #if os(iOS)
-        setupMemoryManagement()
+        if configuration.automaticMemoryManagement {
+            setupMemoryManagement()
+        }
         #endif
     }
 

Tests/GRDBTests/DatabasePoolReleaseMemoryTests.swift

@@ -41,6 +41,60 @@ class DatabasePoolReleaseMemoryTests: GRDBTestCase {
         XCTAssertEqual(openConnectionCount, 0)
     }
 
+#if os(iOS)
+    func testDatabasePoolReleasesMemoryOnPressureEvent() throws {
+        do {
+            // Create a database pool.
+            let dbPool = try makeDatabasePool()
+
+            // Write and read it to ensure readers exist.
+            try dbPool.write { db in
+                try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
+            }
+
+            // Precondition: there are readers.
+            try dbPool.read { _ in }
+            XCTAssertNotEqual(0, dbPool.numberOfReaders)
+
+            // Simulate memory warning.
+            NotificationCenter.default.post(name: NSNotification.Name(rawValue: "UIApplicationDidReceiveMemoryWarningNotification"),
+                                            object: nil)
+            // Block until memory is released, which happens on a global queue.
+            dbPool.barrierWriteWithoutTransaction { _ in }
+
+            // Postcondition: readers removed.
+            XCTAssertEqual(0, dbPool.numberOfReaders)
+        }
+    }
+
+    func testDatabasePoolDoesNotReleaseMemoryOnPressureEventIfDisabled() throws {
+        do {
+            // Create a database pool without automatic memory management.
+            var configuration = dbConfiguration!
+            configuration.automaticMemoryManagement = false
+            let dbPool = try makeDatabasePool(configuration: configuration)
+
+            // Write and read it to ensure readers exist.
+            try dbPool.write { db in
+                try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
+            }
+
+            // Precondition: there are readers.
+            try dbPool.read { _ in }
+            XCTAssertNotEqual(0, dbPool.numberOfReaders)
+
+            // Simulate memory warning.
+            NotificationCenter.default.post(name: NSNotification.Name(rawValue: "UIApplicationDidReceiveMemoryWarningNotification"),
+                                            object: nil)
+            // Block until memory would be released, which would happen on a global queue.
+            dbPool.barrierWriteWithoutTransaction { _ in }
+
+            // Postcondition: there are readers.
+            XCTAssertNotEqual(0, dbPool.numberOfReaders)
+        }
+    }
+#endif
+
     // TODO: fix flaky test
 //    func testDatabasePoolReleaseMemoryClosesReaderConnections() throws {
 //        let countQueue = DispatchQueue(label: "GRDB")