Make ArticlesDatabase an actor. No serial dispatch queue.

Database/Sources/Database/Database.swift

@@ -7,17 +7,12 @@
 //
 
 import Foundation
-import FMDB
 
 public enum DatabaseError: Error, Sendable {
 	case suspended // On iOS, to support background refreshing, a database may be suspended.
 }
 
-/// Result type that provides an FMDatabase or a DatabaseError.
-public typealias DatabaseResult = Result<FMDatabase, DatabaseError>
-
-/// Block that executes database code or handles DatabaseQueueError.
-public typealias DatabaseBlock = (DatabaseResult) -> Void
+// Compatibility — to be removed once we switch to structured concurrency
 
 /// Completion block that provides an optional DatabaseError.
 public typealias DatabaseCompletionBlock = @Sendable (DatabaseError?) -> Void
@@ -27,28 +22,3 @@ public typealias DatabaseIntResult = Result<Int, DatabaseError>
 
 /// Completion block for DatabaseIntResult.
 public typealias DatabaseIntCompletionBlock = @Sendable (DatabaseIntResult) -> Void
-
-// MARK: - Extensions
-
-public extension DatabaseResult {
-	/// Convenience for getting the database from a DatabaseResult.
-	var database: FMDatabase? {
-		switch self {
-		case .success(let database):
-			return database
-		case .failure:
-			return nil
-		}
-	}
-
-	/// Convenience for getting the error from a DatabaseResult.
-	var error: DatabaseError? {
-		switch self {
-		case .success:
-			return nil
-		case .failure(let error):
-			return error
-		}
-	}
-}
-

Database/Sources/Database/DatabaseQueue.swift

@@ -1,259 +0,0 @@
-//
-//  DatabaseQueue.swift
-//  RSDatabase
-//
-//  Created by Brent Simmons on 11/13/19.
-//  Copyright © 2019 Brent Simmons. All rights reserved.
-//
-
-import Foundation
-import SQLite3
-import FMDB
-
-/// Manage a serial queue and a SQLite database.
-/// It replaces RSDatabaseQueue, which is deprecated.
-/// Main-thread only.
-/// Important note: on iOS, the queue can be suspended
-/// in order to support background refreshing.
-public final class DatabaseQueue {
-
-	/// Check to see if the queue is suspended. Read-only.
-	/// Calling suspend() and resume() will change the value of this property.
-	/// This will return true only on iOS — on macOS it’s always false.
-	public var isSuspended: Bool {
-		#if os(iOS)
-		precondition(Thread.isMainThread)
-		return _isSuspended
-		#else
-		return false
-		#endif
-	}
-
-	private var _isSuspended = true
-	private var isCallingDatabase = false
-	private let database: FMDatabase
-	private let databasePath: String
-	private let serialDispatchQueue: DispatchQueue
-	private let targetDispatchQueue: DispatchQueue
-	#if os(iOS)
-	private let databaseLock = NSLock()
-	#endif
-
-	/// When init returns, the database will not be suspended: it will be ready for database calls.
-	public init(databasePath: String) {
-		precondition(Thread.isMainThread)
-
-		self.serialDispatchQueue = DispatchQueue(label: "DatabaseQueue (Serial) - \(databasePath)", attributes: .initiallyInactive)
-		self.targetDispatchQueue = DispatchQueue(label: "DatabaseQueue (Target) - \(databasePath)")
-		self.serialDispatchQueue.setTarget(queue: self.targetDispatchQueue)
-		self.serialDispatchQueue.activate()
-
-		self.databasePath = databasePath
-		self.database = FMDatabase(path: databasePath)!
-		openDatabase()
-		_isSuspended = false
-	}
-
-	// MARK: - Suspend and Resume
-
-	/// Close the SQLite database and don’t allow database calls until resumed.
-	/// This is for iOS, where we need to close the SQLite database in some conditions.
-	///
-	/// After calling suspend, if you call into the database before calling resume,
-	/// your code will not run, and runInDatabaseSync and runInTransactionSync will
-	/// both throw DatabaseQueueError.isSuspended.
-	///
-	/// On Mac, suspend() and resume() are no-ops, since there isn’t a need for them.
-	public func suspend() {
-		#if os(iOS)
-		precondition(Thread.isMainThread)
-		guard !_isSuspended else {
-			return
-		}
-
-		_isSuspended = true
-
-		serialDispatchQueue.suspend()
-		targetDispatchQueue.async {
-			self.lockDatabase()
-			self.database.close()
-			self.unlockDatabase()
-			DispatchQueue.main.async {
-				self.serialDispatchQueue.resume()
-			}
-		}
-		#endif
-	}
-
-	/// Open the SQLite database. Allow database calls again.
-	/// This is also for iOS only.
-	public func resume() {
-		#if os(iOS)
-		precondition(Thread.isMainThread)
-		guard _isSuspended else {
-			return
-		}
-
-		serialDispatchQueue.suspend()
-		targetDispatchQueue.sync {
-			if _isSuspended {
-				lockDatabase()
-				openDatabase()
-				unlockDatabase()
-				_isSuspended = false
-			}
-		}
-		serialDispatchQueue.resume()
-		#endif
-	}
-
-	// MARK: - Make Database Calls
-
-	/// Run a DatabaseBlock synchronously. This call will block the main thread
-	/// potentially for a while, depending on how long it takes to execute
-	/// the DatabaseBlock *and* depending on how many other calls have been
-	/// scheduled on the queue. Use sparingly — prefer async versions.
-	public func runInDatabaseSync(_ databaseBlock: DatabaseBlock) {
-		precondition(Thread.isMainThread)
-		serialDispatchQueue.sync {
-			self._runInDatabase(self.database, databaseBlock, false)
-		}
-	}
-
-	/// Run a DatabaseBlock asynchronously.
-	public func runInDatabase(_ databaseBlock: @escaping DatabaseBlock) {
-		precondition(Thread.isMainThread)
-		serialDispatchQueue.async {
-			self._runInDatabase(self.database, databaseBlock, false)
-		}
-	}
-
-	/// Run a DatabaseBlock wrapped in a transaction synchronously.
-	/// Transactions help performance significantly when updating the database.
-	/// Nevertheless, it’s best to avoid this because it will block the main thread —
-	/// prefer the async `runInTransaction` instead.
-	public func runInTransactionSync(_ databaseBlock: @escaping DatabaseBlock) {
-		precondition(Thread.isMainThread)
-		serialDispatchQueue.sync {
-			self._runInDatabase(self.database, databaseBlock, true)
-		}
-	}
-
-	/// Run a DatabaseBlock wrapped in a transaction asynchronously.
-	/// Transactions help performance significantly when updating the database.
-	public func runInTransaction(_ databaseBlock: @escaping DatabaseBlock) {
-		precondition(Thread.isMainThread)
-		serialDispatchQueue.async {
-			self._runInDatabase(self.database, databaseBlock, true)
-		}
-	}
-
-	/// Run all the lines that start with "create".
-	/// Use this to create tables, indexes, etc.
-	public func runCreateStatements(_ statements: String) throws {
-		precondition(Thread.isMainThread)
-		var error: DatabaseError? = nil
-		runInDatabaseSync { result in
-			switch result {
-			case .success(let database):
-				statements.enumerateLines { (line, stop) in
-					if line.lowercased().hasPrefix("create") {
-						database.executeStatements(line)
-					}
-					stop = false
-				}
-			case .failure(let databaseError):
-				error = databaseError
-			}
-		}
-		if let error = error {
-			throw(error)
-		}
-	}
-
-	/// Compact the database. This should be done from time to time —
-	/// weekly-ish? — to keep up the performance level of a database.
-	/// Generally a thing to do at startup, if it’s been a while
-	/// since the last vacuum() call. You almost certainly want to call
-	/// vacuumIfNeeded instead.
-	public func vacuum() {
-		precondition(Thread.isMainThread)
-		runInDatabase { result in
-			result.database?.executeStatements("vacuum;")
-		}
-	}
-
-	/// Vacuum the database if it’s been more than `daysBetweenVacuums` since the last vacuum.
-	/// Normally you would call this right after initing a DatabaseQueue.
-	///
-	/// - Returns: true if database will be vacuumed.
-	@discardableResult
-	public func vacuumIfNeeded(daysBetweenVacuums: Int) -> Bool {
-		precondition(Thread.isMainThread)
-		let defaultsKey = "DatabaseQueue-LastVacuumDate-\(databasePath)"
-		let minimumVacuumInterval = TimeInterval(daysBetweenVacuums * (60 * 60 * 24)) // Doesn’t have to be precise
-		let now = Date()
-		let cutoffDate = now - minimumVacuumInterval
-		if let lastVacuumDate = UserDefaults.standard.object(forKey: defaultsKey) as? Date {
-			if lastVacuumDate < cutoffDate {
-				vacuum()
-				UserDefaults.standard.set(now, forKey: defaultsKey)
-				return true
-			}
-			return false
-		}
-
-		// Never vacuumed — almost certainly a new database.
-		// Just set the LastVacuumDate pref to now and skip vacuuming.
-		UserDefaults.standard.set(now, forKey: defaultsKey)
-		return false
-	}
-}
-
-private extension DatabaseQueue {
-
-	func lockDatabase() {
-		#if os(iOS)
-		databaseLock.lock()
-		#endif
-	}
-
-	func unlockDatabase() {
-		#if os(iOS)
-		databaseLock.unlock()
-		#endif
-	}
-
-	func _runInDatabase(_ database: FMDatabase, _ databaseBlock: DatabaseBlock, _ useTransaction: Bool) {
-		lockDatabase()
-		defer {
-			unlockDatabase()
-		}
-
-		precondition(!isCallingDatabase)
-
-		isCallingDatabase = true
-		autoreleasepool {
-			if _isSuspended {
-				databaseBlock(.failure(.suspended))
-			}
-			else {
-				if useTransaction {
-					database.beginTransaction()
-				}
-				databaseBlock(.success(database))
-				if useTransaction {
-					database.commit()
-				}
-			}
-		}
-		isCallingDatabase = false
-	}
-
-	func openDatabase() {
-		database.open()
-		database.executeStatements("PRAGMA synchronous = 1;")
-		database.setShouldCacheStatements(true)
-	}
-}
-

Database/Sources/Database/DatabaseTable.swift

@@ -1,139 +0,0 @@
-//
-//  DatabaseTable.swift
-//  RSDatabase
-//
-//  Created by Brent Simmons on 7/16/17.
-//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
-//
-
-import Foundation
-import FMDB
-
-public protocol DatabaseTable {
-
-	var name: String { get }
-}
-
-public extension DatabaseTable {
-	
-	// MARK: Fetching
-
-	func selectRowsWhere(key: String, equals value: Any, in database: FMDatabase) -> FMResultSet? {
-		
-		return database.rs_selectRowsWhereKey(key, equalsValue: value, tableName: name)
-	}
-
-	func selectSingleRowWhere(key: String, equals value: Any, in database: FMDatabase) -> FMResultSet? {
-
-		return database.rs_selectSingleRowWhereKey(key, equalsValue: value, tableName: name)
-	}
-
-	func selectRowsWhere(key: String, inValues values: [Any], in database: FMDatabase) -> FMResultSet? {
-
-		if values.isEmpty {
-			return nil
-		}
-		return database.rs_selectRowsWhereKey(key, inValues: values, tableName: name)
-	}
-
-	// MARK: Deleting
-
-	func deleteRowsWhere(key: String, equalsAnyValue values: [Any], in database: FMDatabase) {
-		
-		if values.isEmpty {
-			return
-		}
-		database.rs_deleteRowsWhereKey(key, inValues: values, tableName: name)
-	}
-
-	// MARK: Updating
-
-	func updateRowsWithValue(_ value: Any, valueKey: String, whereKey: String, matches: [Any], database: FMDatabase) {
-		
-		let _ = database.rs_updateRows(withValue: value, valueKey: valueKey, whereKey: whereKey, inValues: matches, tableName: self.name)
-	}
-	
-	func updateRowsWithDictionary(_ dictionary: DatabaseDictionary, whereKey: String, matches: Any, database: FMDatabase) {
-		
-		let _ = database.rs_updateRows(with: dictionary, whereKey: whereKey, equalsValue: matches, tableName: self.name)
-	}
-	
-	// MARK: Saving
-
-	func insertRows(_ dictionaries: [DatabaseDictionary], insertType: RSDatabaseInsertType, in database: FMDatabase) {
-
-		dictionaries.forEach { (oneDictionary) in
-			let _ = database.rs_insertRow(with: oneDictionary, insertType: insertType, tableName: self.name)
-		}
-	}
-
-	func insertRow(_ rowDictionary: DatabaseDictionary, insertType: RSDatabaseInsertType, in database: FMDatabase) {
-
-		insertRows([rowDictionary], insertType: insertType, in: database)
-	}
-
-	// MARK: Counting
-
-	func numberWithCountResultSet(_ resultSet: FMResultSet) -> Int {
-
-		guard resultSet.next() else {
-			return 0
-		}
-		return Int(resultSet.int(forColumnIndex: 0))
-	}
-
-	func numberWithSQLAndParameters(_ sql: String, _ parameters: [Any], in database: FMDatabase) -> Int {
-
-		if let resultSet = database.executeQuery(sql, withArgumentsIn: parameters) {
-			return numberWithCountResultSet(resultSet)
-		}
-		return 0
-	}
-
-	// MARK: Mapping
-
-	func mapResultSet<T>(_ resultSet: FMResultSet, _ completion: (_ resultSet: FMResultSet) -> T?) -> [T] {
-
-		var objects = [T]()
-		while resultSet.next() {
-			if let obj = completion(resultSet) {
-				objects += [obj]
-			}
-		}
-		return objects
-	}
-
-	// MARK: Columns
-
-	func containsColumn(_ columnName: String, in database: FMDatabase) -> Bool {
-		if let resultSet = database.executeQuery("select * from \(name) limit 1;", withArgumentsIn: nil) {
-			if let columnMap = resultSet.columnNameToIndexMap {
-				if let _ = columnMap[columnName.lowercased()] {
-					return true
-				}
-			}
-		}
-		return false
-	}
-}
-
-public extension FMResultSet {
-
-	func compactMap<T>(_ completion: (_ row: FMResultSet) -> T?) -> [T] {
-
-		var objects = [T]()
-		while next() {
-			if let obj = completion(self) {
-				objects += [obj]
-			}
-		}
-		close()
-		return objects
-	}
-
-	func mapToSet<T>(_ completion: (_ row: FMResultSet) -> T?) -> Set<T> {
-
-		return Set(compactMap(completion))
-	}
-}
-

Database/Sources/Database/FMDatabase+Extras.swift

@@ -46,7 +46,47 @@ public extension FMDatabase {
 	func insertRows(_ dictionaries: [DatabaseDictionary], insertType: RSDatabaseInsertType, tableName: String) {
 
 		for dictionary in dictionaries {
-			_ = rs_insertRow(with: dictionary, insertType: insertType, tableName: tableName)
+			insertRow(dictionary, insertType: insertType, tableName: tableName)
 		}
 	}
+
+	func insertRow(_ dictionary: DatabaseDictionary, insertType: RSDatabaseInsertType, tableName: String) {
+
+		rs_insertRow(with: dictionary, insertType: insertType, tableName: tableName)
+	}
+
+	func updateRowsWithValue(_ value: Any, valueKey: String, whereKey: String, equalsAnyValue values: [Any], tableName: String) {
+
+		rs_updateRows(withValue: value, valueKey: valueKey, whereKey: whereKey, inValues: values, tableName: tableName)
+	}
+
+	func updateRowsWithValue(_ value: Any, valueKey: String, whereKey: String, equals match: Any, tableName: String) {
+
+		updateRowsWithValue(value, valueKey: valueKey, whereKey: whereKey, equalsAnyValue: [match], tableName: tableName)
+	}
+
+	func updateRowsWithDictionary(_ dictionary: [String: Any], whereKey: String, equals value: Any, tableName: String) {
+
+		rs_updateRows(with: dictionary, whereKey: whereKey, equalsValue: value, tableName: tableName)
+	}
+
+	func deleteRowsWhere(key: String, equalsAnyValue values: [Any], tableName: String) {
+
+		rs_deleteRowsWhereKey(key, inValues: values, tableName: tableName)
+	}
+
+	func selectRowsWhere(key: String, equalsAnyValue values: [Any], tableName: String) -> FMResultSet? {
+		
+		rs_selectRowsWhereKey(key, inValues: values, tableName: tableName)
+	}
+
+	func count(sql: String, parameters: [Any]?, tableName: String) -> Int? {
+
+		guard let resultSet = executeQuery(sql, withArgumentsIn: parameters) else {
+			return nil
+		}
+		
+		let count = resultSet.intWithCountResult()
+		return count
+	}
 }

Database/Sources/Database/FMResultSet+Extras.swift

@@ -16,7 +16,27 @@ public extension FMResultSet {
 			return nil
 		}
 
-		return Int(long(forColumnIndex: 0))
+		let count = Int(long(forColumnIndex: 0))
+		close()
+		
+		return count
+	}
+
+	func compactMap<T>(_ completion: (_ row: FMResultSet) -> T?) -> [T] {
+
+		var objects = [T]()
+		while next() {
+			if let obj = completion(self) {
+				objects += [obj]
+			}
+		}
+		close()
+		return objects
+	}
+
+	func mapToSet<T>(_ completion: (_ row: FMResultSet) -> T?) -> Set<T> {
+
+		return Set(compactMap(completion))
 	}
 }
 

Database/Sources/Database/Related Objects/DatabaseRelatedObjectsTable.swift

@@ -11,8 +11,9 @@ import FMDB
 
 // Protocol for a database table for related objects — authors and attachments in NetNewsWire, for instance.
 
-public protocol DatabaseRelatedObjectsTable: DatabaseTable {
+public protocol DatabaseRelatedObjectsTable {
 
+	var name: String { get }
 	var databaseIDKey: String { get}
 	var cache: DatabaseObjectCache { get }
 	
@@ -49,7 +50,7 @@ public extension DatabaseRelatedObjectsTable {
 			return cachedObjects
 		}
 
-		guard let resultSet = selectRowsWhere(key: databaseIDKey, inValues: Array(databaseIDsToFetch), in: database) else {
+		guard let resultSet = database.selectRowsWhere(key: databaseIDKey, equalsAnyValue: Array(databaseIDsToFetch), tableName: name) else {
 			return cachedObjects
 		}
 
@@ -76,7 +77,7 @@ public extension DatabaseRelatedObjectsTable {
 
 		cache.add(objectsToSave)
 		if let databaseDictionaries = objectsToSave.databaseDictionaries() {
-			insertRows(databaseDictionaries, insertType: .orIgnore, in: database)
+			database.insertRows(databaseDictionaries, insertType: .orIgnore, tableName: name)
 		}
 	}