SQLAny

Author: wickwirew

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -22,7 +22,7 @@ public struct SwiftLanguage: Language {
             case "INTEGER": "Int"
             case "TEXT": "String"
             case "BLOB": "Data"
-            default: "Any"
+            default: "SQLAny"
             }
         case let .optional(ty): "\(builtinType(for: ty))?"
         case let .row(.unknown(ty)): "[\(builtinType(for: ty))]"

Sources/Compiler/Sema/InferenceState.swift

@@ -191,9 +191,7 @@ extension InferenceState {
         case let (ty, .var(tv)):
             validateCanUnify(type: ty, with: tv.kind, at: location)
             substitute(tv, for: ty)
-        case (.integer, .real):
-            return // Not equal but valid to use together
-        case (.real, .integer):
+        case (.integer, .real), (.real, .integer), (.any, _), (_, .any):
             return // Not equal but valid to use together
         case let (.fn(args1, ret1), .fn(args2, ret2)):
             unify(args1, with: args2, at: location)

Sources/Feather/SQLAny.swift

@@ -0,0 +1,104 @@
+//
+//  SQLAny.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 5/10/25.
+//
+
+import Foundation
+import SQLite3
+
+/// SQLite supports an `ANY` type. Mapping to a `Swift.Any` would
+/// not be a smart idea and would not implement things like
+/// `Hashable` and `Sendable`. This wraps any possible value that
+/// SQLite can throw at us.
+///
+/// SQLite type can be `NULL` but that is not acknowledged here
+/// and nullability is handled at the constraint level like
+/// every other type.
+public enum SQLAny: Sendable, Hashable {
+    /// Maps to `TEXT`
+    case string(String)
+    /// Maps to `INTEGER` and `INT`
+    case int(Int)
+    /// Maps to `REAL`
+    case double(Double)
+    /// Maps to `BLOB`
+    case data(Data)
+    
+    /// The value if it is a `.string`
+    public var string: String? {
+        guard case let .string(value) = self else { return nil }
+        return value
+    }
+    
+    /// The value if it is a `.int`
+    public var int: Int? {
+        guard case let .int(value) = self else { return nil }
+        return value
+    }
+    
+    /// The value if it is a `.double`
+    public var double: Double? {
+        guard case let .double(value) = self else { return nil }
+        return value
+    }
+    
+    /// The value if it is a `.data`
+    public var data: Data? {
+        guard case let .data(value) = self else { return nil }
+        return value
+    }
+}
+
+extension SQLAny: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .string(let string): string
+        case .int(let int): int.description
+        case .double(let double): double.description
+        case .data(let data): data.description
+        }
+    }
+}
+
+extension SQLAny: ExpressibleByStringLiteral {
+    public init(stringLiteral value: StringLiteralType) {
+        self = .string(value)
+    }
+}
+
+extension SQLAny: ExpressibleByIntegerLiteral {
+    public init(integerLiteral value: IntegerLiteralType) {
+        self = .int(value)
+    }
+}
+
+extension SQLAny: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: FloatLiteralType) {
+        self = .double(value)
+    }
+}
+
+extension SQLAny: DatabasePrimitive {
+    @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
+        let type = sqlite3_column_type(cursor, index)
+        switch type {
+        case SQLITE_TEXT: self = try .string(String(from: cursor, at: index))
+        case SQLITE_INTEGER: self = try .int(Int(from: cursor, at: index))
+        case SQLITE_FLOAT: self = try .double(Double(from: cursor, at: index))
+        case SQLITE_BLOB: self = try .data(Data(from: cursor, at: index))
+        case SQLITE_NULL: throw .decodingError("Expected non nil value for `ANY` column type")
+        default: fatalError("Unknown column type code: \(type)")
+        }
+    }
+
+    @inlinable public func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError) {
+        switch self {
+        case .string(let string): try string.bind(to: statement, at: index)
+        case .int(let int): try int.bind(to: statement, at: index)
+        case .double(let double): try double.bind(to: statement, at: index)
+        case .data(let data): try data.bind(to: statement, at: index)
+        }
+    }
+}

Tests/FeatherTests/DatabaseMacroTests.swift

@@ -13,7 +13,7 @@ struct DatabaseMacroTests {
     @Test func insertAndSelect() async throws {
         let database = try TestDB.inMemory()
 
-        try await database.insertFooQuery.execute(with: .init(bar: 1, baz: "Meow"))
+        try await database.insertFooQuery.execute(with: .init(bar: 1, baz: "Meow", qux: 1))
 
         let foos = try await database.selectFooQuery.execute()
 
@@ -27,12 +27,12 @@ struct DatabaseMacroTests {
         @Query("SELECT * FROM foo")
         var selectFooQuery: SelectFooDatabaseQuery
 
-        @Query("INSERT INTO foo (bar, baz) VALUES (?, ?)", inputName: "Meow")
+        @Query("INSERT INTO foo (bar, baz, qux) VALUES (?, ?, ?)", inputName: "Meow")
         var insertFooQuery: InsertFooDatabaseQuery
 
         static var migrations: [String] {
             return [
-                "CREATE TABLE foo (bar INTEGER, baz TEXT);"
+                "CREATE TABLE foo (bar INTEGER, baz TEXT, qux ANY);"
             ]
         }
     }