Update SQLite usage

Author: colemancda

Sources/CoreModelSQLite/AttributeValue.swift

@@ -12,34 +12,36 @@ import SQLite
 internal extension AttributeValue {
 
     /// Convert to a SQLite binding value.
+    ///
+    /// `nil` represents a SQL `NULL`.
     var binding: Binding? {
         switch self {
         case .null:
             return nil
         case let .string(value):
-            return value
+            return .text(value)
         case let .uuid(value):
-            return value.uuidString
+            return .text(value.uuidString)
         case let .url(value):
-            return value.absoluteString
+            return .text(value.absoluteString)
         case let .data(value):
-            return Blob(bytes: [UInt8](value))
+            return Blob(bytes: [UInt8](value)).binding
         case let .date(value):
-            return value.timeIntervalSince1970
+            return .double(value.timeIntervalSince1970)
         case let .bool(value):
-            return Int64(value ? 1 : 0)
+            return .integer(value ? 1 : 0)
         case let .int16(value):
-            return Int64(value)
+            return .integer(Int64(value))
         case let .int32(value):
-            return Int64(value)
+            return .integer(Int64(value))
         case let .int64(value):
-            return value
+            return .integer(value)
         case let .float(value):
-            return Double(value)
+            return .double(Double(value))
         case let .double(value):
-            return value
+            return .double(value)
         case let .decimal(value):
-            return value.description
+            return .text(value.description)
         }
     }
 
@@ -81,27 +83,27 @@ internal extension AttributeValue {
             }
             self = .double(value)
         case .string:
-            guard let value = binding as? String else {
+            guard let value = binding.textValue else {
                 throw SQLiteDatabaseError.invalidBinding(binding, type)
             }
             self = .string(value)
         case .data:
-            guard let value = binding as? Blob else {
+            guard let value = binding.blobValue else {
                 throw SQLiteDatabaseError.invalidBinding(binding, type)
             }
-            self = .data(Data(value.bytes))
+            self = .data(Data(value))
         case .date:
             guard let value = binding.doubleValue else {
                 throw SQLiteDatabaseError.invalidBinding(binding, type)
             }
             self = .date(Date(timeIntervalSince1970: value))
         case .uuid:
-            guard let string = binding as? String, let value = UUID(uuidString: string) else {
+            guard let string = binding.textValue, let value = UUID(uuidString: string) else {
                 throw SQLiteDatabaseError.invalidBinding(binding, type)
             }
             self = .uuid(value)
         case .url:
-            guard let string = binding as? String, let value = URL(string: string) else {
+            guard let string = binding.textValue, let value = URL(string: string) else {
                 throw SQLiteDatabaseError.invalidBinding(binding, type)
             }
             self = .url(value)
@@ -114,43 +116,44 @@ internal extension AttributeValue {
     }
 }
 
-private extension Binding {
+internal extension Binding {
 
+    /// The integer value, converting `REAL` and `TEXT` where possible.
     var int64Value: Int64? {
-        switch self {
-        case let value as Int64:
-            return value
-        case let value as Double:
-            return Int64(exactly: value)
-        case let value as String:
-            return Int64(value)
-        default:
+        integer
+    }
+
+    /// The floating-point value, converting `INTEGER` and `TEXT` where possible.
+    var doubleValue: Double? {
+        double
+    }
+
+    /// The stored text value, without converting numeric storage classes to text.
+    var textValue: String? {
+        guard case let .text(value) = self else {
             return nil
         }
+        return value
     }
 
-    var doubleValue: Double? {
-        switch self {
-        case let value as Double:
-            return value
-        case let value as Int64:
-            return Double(value)
-        case let value as String:
-            return Double(value)
-        default:
+    /// The stored blob bytes, only for `BLOB` values.
+    var blobValue: [UInt8]? {
+        guard case .blob = self else {
             return nil
         }
+        return bytes
     }
 
+    /// The decimal value, parsed from `TEXT` or converted from a numeric storage class.
     var decimalValue: Decimal? {
         switch self {
-        case let value as String:
+        case let .text(value):
             return Decimal(string: value)
-        case let value as Double:
+        case let .double(value):
             return Decimal(value)
-        case let value as Int64:
+        case let .integer(value):
             return Decimal(value)
-        default:
+        case .blob, .null:
             return nil
         }
     }

Sources/CoreModelSQLite/CustomFunction.swift

@@ -8,106 +8,42 @@
 import Foundation
 import CoreModel
 import SQLite
-#if canImport(Darwin)
-import SQLite3
-#elseif canImport(SQLiteSwiftCSQLite)
-import SQLiteSwiftCSQLite
-#elseif canImport(CSQLite)
-import CSQLite
-#else
-import SQLite3
-#endif
-
-// Registers custom scalar functions by calling `sqlite3_create_function_v2` directly
-// with `@convention(c)` function pointers, rather than SQLite.swift's `createFunction`.
-// SQLite.swift registers the callback with a `@convention(block)` closure cast to a raw
-// pointer, which is unreliable off Apple platforms (upstream
-// https://github.com/stephencelis/SQLite.swift/issues/1071). A plain C function pointer
-// plus a retained context pointer works identically on every platform.
-
-/// The SQLite `SQLITE_TRANSIENT` sentinel destructor, telling SQLite to copy a result
-/// value immediately (it is a macro in C, so it isn't imported).
-private let transientDestructor = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
-
-/// Retains a ``DatabaseFunction`` so it can be passed through SQLite as an opaque pointer
-/// and recovered inside the C callback.
-private final class FunctionBox {
-    let function: DatabaseFunction
-    init(_ function: DatabaseFunction) { self.function = function }
-}
 
 internal extension SQLite.Connection {
 
-    /// Registers a `DatabaseFunction` with this connection via the SQLite C API.
+    /// Registers a `DatabaseFunction` as a custom SQL scalar function.
     func register(function: DatabaseFunction) throws {
-        let box = Unmanaged.passRetained(FunctionBox(function))
-        let flags = SQLITE_UTF8 | (function.deterministic ? SQLITE_DETERMINISTIC : 0)
-        let argumentCount = function.argumentCount.map { Int32($0) } ?? -1
-        let code = sqlite3_create_function_v2(
-            handle,
+        let evaluate = function.evaluate
+        try createFunction(
             function.name,
-            argumentCount,
-            flags,
-            box.toOpaque(),
-            { context, argc, argv in
-                let function = Unmanaged<FunctionBox>.fromOpaque(sqlite3_user_data(context)).takeUnretainedValue().function
-                var arguments = [AttributeValue?]()
-                arguments.reserveCapacity(Int(argc))
-                for index in 0..<Int(argc) {
-                    arguments.append(argumentValue(argv?[index]))
-                }
-                setResult(context, function.evaluate(arguments))
-            },
-            nil, // xStep (scalar function, no aggregate)
-            nil, // xFinal
-            { pointer in
-                // Balance `passRetained` when SQLite drops the function.
-                guard let pointer else { return }
-                Unmanaged<FunctionBox>.fromOpaque(pointer).release()
+            argumentCount: function.argumentCount.map { Int32($0) },
+            deterministic: function.deterministic
+        ) { arguments in
+            let values: [AttributeValue?] = arguments.map { AttributeValue(functionArgument: $0) }
+            guard let result = evaluate(values), let binding = result.binding else {
+                return .null
             }
-        )
-        guard code == SQLITE_OK else {
-            box.release() // xDestroy isn't called when registration fails
-            throw SQLiteDatabaseError.unableToCreateFunction(function.name, code)
+            return binding
         }
     }
 }
 
-/// Read a SQLite argument value into an ``AttributeValue``, inferring its shape from the
-/// value's runtime storage class.
-private func argumentValue(_ value: OpaquePointer?) -> AttributeValue {
-    switch sqlite3_value_type(value) {
-    case SQLITE_INTEGER:
-        return .int64(sqlite3_value_int64(value))
-    case SQLITE_FLOAT:
-        return .double(sqlite3_value_double(value))
-    case SQLITE_TEXT:
-        guard let text = sqlite3_value_text(value) else { return .null }
-        return .string(String(cString: text))
-    case SQLITE_BLOB:
-        guard let bytes = sqlite3_value_blob(value) else { return .data(Data()) }
-        return .data(Data(bytes: bytes, count: Int(sqlite3_value_bytes(value))))
-    default:
-        return .null
-    }
-}
-
-/// Set a function's result on the SQLite context from an ``AttributeValue``.
-private func setResult(_ context: OpaquePointer?, _ value: AttributeValue?) {
-    guard let value, let binding = value.binding else {
-        sqlite3_result_null(context)
-        return
-    }
-    switch binding {
-    case let integer as Int64:
-        sqlite3_result_int64(context, integer)
-    case let double as Double:
-        sqlite3_result_double(context, double)
-    case let text as String:
-        sqlite3_result_text(context, text, -1, transientDestructor)
-    case let blob as Blob:
-        sqlite3_result_blob(context, blob.bytes, Int32(blob.bytes.count), transientDestructor)
-    default:
-        sqlite3_result_null(context)
+private extension AttributeValue {
+
+    /// Read a SQL function argument into an ``AttributeValue``, inferring its shape from
+    /// the value's storage class.
+    init(functionArgument binding: Binding) {
+        switch binding {
+        case let .integer(value):
+            self = .int64(value)
+        case let .double(value):
+            self = .double(value)
+        case let .text(value):
+            self = .string(value)
+        case .blob:
+            self = .data(Data(binding.bytes ?? []))
+        case .null:
+            self = .null
+        }
     }
 }

Sources/CoreModelSQLite/Database.swift

@@ -36,20 +36,20 @@ public actor SQLiteDatabase {
     /// file and, being read-only, can never create the schema itself; without this, a
     /// fetch through the view context before any write happens throws "no such table".
     public init(
-        connection: SQLite.Connection,
+        connection: consuming SQLite.Connection,
         model: Model
     ) throws {
-        self.connection = connection
         self.model = model
         try connection.createTables(model: model)
+        self.connection = connection
     }
 }
 
 public extension SQLiteDatabase {
 
     /// Open or create a database file at the specified path.
     init(path: String, model: Model) throws {
-        let connection = try Connection(path)
+        let connection = try Connection(path: path)
         try self.init(connection: connection, model: model)
     }
 }
@@ -178,7 +178,7 @@ internal extension Connection {
     func fetch(_ entity: EntityName, for id: ObjectID, model: Model) throws -> ModelData? {
         let entityDescription = try model.entity(entity)
         let sql = "SELECT * FROM \(entity.rawValue.quotedIdentifier) WHERE \(SQLiteDatabase.primaryKeyColumn.quotedIdentifier) = ?"
-        let statement = try prepare(sql, [id.rawValue])
+        let statement = try prepare(sql, [id.rawValue.binding])
         guard let row = try statement.rowDictionaries().first else {
             return nil
         }
@@ -210,7 +210,7 @@ internal extension Connection {
         let statement = try prepare(query.sql, query.bindings)
         var results = [ObjectID]()
         while let row = try statement.failableNext() {
-            guard let value = row[0] as? String else { continue }
+            guard let value = row[0]?.textValue else { continue }
             results.append(ObjectID(rawValue: value))
         }
         return results
@@ -219,7 +219,7 @@ internal extension Connection {
     func count(_ fetchRequest: FetchRequest, model: Model) throws -> UInt {
         let entityDescription = try model.entity(fetchRequest.entity)
         let query = try fetchRequest.sqlFragment(for: entityDescription, model: model, columns: "COUNT(*)")
-        guard let count = try scalar(query.sql, query.bindings) as? Int64 else {
+        guard let count = try scalar(query.sql, query.bindings)?.integer else {
             return 0
         }
         return UInt(count)
@@ -250,7 +250,7 @@ internal extension Connection {
                     case .toOne:
                         // one/many-to-many: nullify the foreign key on the destination table
                         let sql = "UPDATE \(relationship.destinationEntity.rawValue.quotedIdentifier) SET \(relationship.inverseRelationship.rawValue.quotedIdentifier) = NULL WHERE \(relationship.inverseRelationship.rawValue.quotedIdentifier) = ?"
-                        try run(sql, [id.rawValue])
+                        try run(sql, [id.rawValue.binding])
                     case .toMany:
                         // many-to-many: drop this row's links from the join table
                         let joinTable = JoinTable(entity: entity, relationship: relationship)
@@ -260,12 +260,12 @@ internal extension Connection {
                     // only a one-to-one inverse (the other table holding a back-reference) needs explicit nullify
                     if try model.inverseType(of: relationship) == .toOne {
                         let sql = "UPDATE \(relationship.destinationEntity.rawValue.quotedIdentifier) SET \(relationship.inverseRelationship.rawValue.quotedIdentifier) = NULL WHERE \(relationship.inverseRelationship.rawValue.quotedIdentifier) = ?"
-                        try run(sql, [id.rawValue])
+                        try run(sql, [id.rawValue.binding])
                     }
                 }
             }
             let sql = "DELETE FROM \(entity.rawValue.quotedIdentifier) WHERE \(SQLiteDatabase.primaryKeyColumn.quotedIdentifier) = ?"
-            try run(sql, [id.rawValue])
+            try run(sql, [id.rawValue.binding])
         }
     }
 
@@ -320,10 +320,10 @@ internal extension Connection {
                 // one-to-many: rewrite the foreign key on the destination table
                 let table = relationship.destinationEntity.rawValue.quotedIdentifier
                 let foreignKey = relationship.inverseRelationship.rawValue.quotedIdentifier
-                try run("UPDATE \(table) SET \(foreignKey) = NULL WHERE \(foreignKey) = ?", [value.id.rawValue])
+                try run("UPDATE \(table) SET \(foreignKey) = NULL WHERE \(foreignKey) = ?", [value.id.rawValue.binding])
                 if destinationIDs.isEmpty == false {
                     let placeholders = repeatElement("?", count: destinationIDs.count).joined(separator: ", ")
-                    let bindings: [Binding?] = [value.id.rawValue] + destinationIDs.map { $0.rawValue }
+                    let bindings: [Binding?] = [value.id.rawValue.binding] + destinationIDs.map { $0.rawValue.binding }
                     try run("UPDATE \(table) SET \(foreignKey) = ? WHERE \(SQLiteDatabase.primaryKeyColumn.quotedIdentifier) IN (\(placeholders))", bindings)
                 }
             case .toMany:
@@ -340,10 +340,10 @@ internal extension Connection {
             switch try model.inverseType(of: relationship) {
             case .toOne:
                 let sql = "SELECT \(SQLiteDatabase.primaryKeyColumn.quotedIdentifier) FROM \(relationship.destinationEntity.rawValue.quotedIdentifier) WHERE \(relationship.inverseRelationship.rawValue.quotedIdentifier) = ?"
-                let statement = try prepare(sql, [value.id.rawValue])
+                let statement = try prepare(sql, [value.id.rawValue.binding])
                 var results = [ObjectID]()
                 while let row = try statement.failableNext() {
-                    guard let idString = row[0] as? String else { continue }
+                    guard let idString = row[0]?.textValue else { continue }
                     results.append(ObjectID(rawValue: idString))
                 }
                 destinationIDs = results

Sources/CoreModelSQLite/EntityDescription.swift

@@ -25,7 +25,7 @@ internal extension SchemaChanger {
 
 internal extension SchemaChanger.CreateTableDefinition {
 
-    func addColumns(_ entity: EntityDescription) {
+    mutating func addColumns(_ entity: EntityDescription) {
 
         // add ID column
         let id = ColumnDefinition(