WIP - more adapter updates

Author: wickwirew

Sources/Compiler/Gen/Language.swift

@@ -51,24 +51,11 @@ extension Language {
         schema: Schema
     ) throws -> String {
         let values = try assemble(queries: queries, schema: schema)
-        
-        let builtinAdapters = builtinAdapterTypes
-            .map(adapterName(from:))
-        
-        // Get a list of all adapters used. Right now we only have to look at the
-        // tables since any output would inhereit the encoding of the source table.
-        let adapters: Set<String> = values.tables.reduce(into: []) { adapters, table in
-            for field in table.fields.values {
-                guard let adapter = field.type.adapter else { continue }
-                adapters.insert(adapter)
-            }
-        }
-        
         return try file(
             migrations: migrations,
             tables: values.tables,
             queries: values.queries,
-            adapters: adapters.subtracting(builtinAdapters).sorted()
+            adapters: values.adapters
         )
     }
 
@@ -77,11 +64,25 @@ extension Language {
         schema: Schema
     ) throws -> (
         tables: [GeneratedModel],
-        queries: [(String?, [GeneratedQuery])]
+        queries: [(String?, [GeneratedQuery])],
+        adapters: [String]
     ) {
         let tables = Dictionary(schema.tables.map { ($0.key.name, model(for: $0.value)) }, uniquingKeysWith: { $1 })
         let queries = queries.map { ($0.map { "\($0)Queries" }, $1.map { query(for: $0, tables: tables) }) }
-        return (tables.values.sorted{ $0.name < $1.name }, queries)
+        
+        let builtinAdapters = builtinAdapterTypes
+            .map(adapterName(from:))
+        
+        // Get a list of all adapters used. Right now we only have to look at the
+        // tables since any output would inhereit the encoding of the source table.
+        let adapters: Set<String> = tables.reduce(into: []) { adapters, table in
+            for field in table.value.fields.values {
+                guard let adapter = field.type.adapter else { continue }
+                adapters.insert(adapter)
+            }
+        }
+        
+        return (tables.values.sorted{ $0.name < $1.name }, queries, adapters.subtracting(builtinAdapters).sorted())
     }
 
     private func query(
@@ -385,6 +386,21 @@ public struct GeneratedModel: Equatable {
     /// Whether or not this was generated for a table
     let isTable: Bool
     let nonOptionalIndices: [Int]
+    /// Whether this model can be decoded with the adapters or not
+    let requiresAdapters: Bool
+    
+    init(
+        name: String,
+        fields: OrderedDictionary<String, GeneratedField>,
+        isTable: Bool,
+        nonOptionalIndices: [Int]
+    ) {
+        self.name = name
+        self.fields = fields
+        self.isTable = isTable
+        self.nonOptionalIndices = nonOptionalIndices
+        self.requiresAdapters = fields.contains{ $0.value.type.requiresAdapters }
+    }
 }
 
 public struct GeneratedField: Equatable {
@@ -398,6 +414,11 @@ public struct GeneratedField: Equatable {
     /// The name is accessed many times so we can just calculate
     /// it once and reuse it.
     let typeName: String
+    
+    /// Whether this type can be decoded with an adapter or not
+    var requiresAdapter: Bool {
+        return type.adapter != nil
+    }
 }
 
 public struct GeneratedQuery {
@@ -454,4 +475,14 @@ public enum GenerationType: Equatable {
         case .encoded(_, _, let adapter): adapter
         }
     }
+    
+    var requiresAdapters: Bool {
+        switch self {
+        case .void, .builtin: false
+        case .optional(let optional): optional.requiresAdapters
+        case .array(let array): array.requiresAdapters
+        case .encoded: true
+        case .model(let model): model.requiresAdapters
+        }
+    }
 }

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -129,7 +129,8 @@ public struct SwiftLanguage: Language {
         databaseName: String,
         tables: [GeneratedModel],
         queries: [GeneratedQuery],
-        addConnection: Bool
+        addConnection: Bool,
+        adapters: [String]
     ) -> [String] {
         var decls: [String] = []
 
@@ -142,6 +143,8 @@ public struct SwiftLanguage: Language {
 
         writer.write("let connection: any Otter.Connection")
         take()
+        self.adapters(adapters: adapters)
+        take()
 
         for table in tables {
             declaration(for: table, isOutput: true)
@@ -173,20 +176,7 @@ public struct SwiftLanguage: Language {
 
         writer.braces {
             writer.write(line: "let connection: any Otter.Connection")
-            
-            writer.write(line: "let adapters: Adapters")
-            // Don't require initialization if there are no custom adapters
-            if adapters.isEmpty {
-                writer.write(" = Adapters()")
-            }
-            writer.newline()
-            
-            writer.write(line: "struct Adapters ")
-            writer.braces {
-                for adapter in adapters {
-                    writer.write(line: "let ", adapter, ": DatabaseValueAdapter")
-                }
-            }
+            self.adapters(adapters: adapters)
 
             writer.newline()
 
@@ -224,6 +214,22 @@ public struct SwiftLanguage: Language {
         }
     }
 
+    private func adapters(adapters: [String]) {
+        writer.write(line: "let adapters: Adapters")
+        writer.newline()
+        
+        if adapters.isEmpty {
+            writer.write(line: "typealias Adapters = DefaultAdapters")
+        } else {
+            writer.write(line: "struct Adapters: Otter.Adapters ")
+            writer.braces {
+                for adapter in adapters {
+                    writer.write(line: "let ", adapter, ": any DatabaseValueAdapter")
+                }
+            }
+        }
+    }
+    
     private func queries(name: String, queries: [GeneratedQuery]) {
         writer.write(line: "struct ", name, " {")
         writer.indent()
@@ -348,10 +354,16 @@ public struct SwiftLanguage: Language {
         } else {
             switch query.outputCardinality {
             case .single:
-                writer.write(line: "return try statement.fetchOne()")
+                writer.write(line: "return try statement.fetchOne(")
             case .many:
-                writer.write(line: "return try statement.fetchAll()")
+                writer.write(line: "return try statement.fetchAll(")
+            }
+            
+            if query.output.requiresAdapters {
+                writer.write("adapters: adapters")
             }
+            
+            writer.write(")")
         }
 
         writer.unindent()
@@ -407,7 +419,11 @@ public struct SwiftLanguage: Language {
         }
 
         if isOutput {
-            writer.write(", RowDecodable")
+            if model.requiresAdapters {
+                writer.write(", RowDecodableWithAdapters")
+            } else {
+                writer.write(", RowDecodable")
+            }
         }
 
         writer.write(" {")
@@ -491,6 +507,12 @@ public struct SwiftLanguage: Language {
         writer.indent()
         writer.write(line: "row: borrowing Otter.Row,")
         writer.write(line: "startingAt start: Int32")
+        
+        if model.requiresAdapters {
+            writer.write(",")
+            writer.write(line: "adapters: ", options.databaseName, ".Adapters")
+        }
+        
         writer.unindent()
         writer.write(line: ") throws(Otter.OtterError) {")
 
@@ -506,10 +528,18 @@ public struct SwiftLanguage: Language {
                 writer.write("row.value(at: start + ", index.description, ")")
                 index += 1
             case let .model(model):
-                writer.write("row.embedded(at: start + ", index.description, ")")
+                writer.write("row.embedded(at: start + ", index.description)
+                if model.requiresAdapters {
+                    writer.write(", adapters: adapters")
+                }
+                writer.write(")")
                 index += model.fields.count
             case let .optional(.model(model)):
-                writer.write("row.optionallyEmbedded(at: start + ", index.description, ")")
+                writer.write("row.optionallyEmbedded(at: start + ", index.description)
+                if model.requiresAdapters {
+                    writer.write(", adapters: adapters")
+                }
+                writer.write(")")
                 index += model.fields.count
             case let .encoded(storage, _, adapter):
                 writer.write("row.value(at: start + ", index.description, ", using: adapters.", adapter, ", storage: ", typeName(for: storage), ".self)")

Sources/Otter/Cursor.swift

@@ -7,13 +7,15 @@
 
 import SQLite3
 
-public struct Cursor<Element: RowDecodable>: ~Copyable {
+public struct Cursor<Element>: ~Copyable {
     private let statement: Statement
 
     public init(of statement: consuming Statement) {
         self.statement = statement
     }
+}
 
+extension Cursor where Element: RowDecodable {
     public mutating func next() throws(OtterError) -> Element? {
         switch try statement.step() {
         case .row:
@@ -25,6 +27,18 @@ public struct Cursor<Element: RowDecodable>: ~Copyable {
     }
 }
 
+extension Cursor where Element: RowDecodableWithAdapters {
+    public mutating func next(adapters: Element.Adapters) throws(OtterError) -> Element? {
+        switch try statement.step() {
+        case .row:
+            let row = Row(sqliteStatement: statement.raw)
+            return try Element(row: row, startingAt: 0, adapters: adapters)
+        case .done:
+            return nil
+        }
+    }
+}
+
 public struct Row: ~Copyable {
     @usableFromInline let sqliteStatement: OpaquePointer
 
@@ -39,7 +53,7 @@ public struct Row: ~Copyable {
     /// Decodes the column at the index as the `Storage.Value` type
     @inlinable public func value<Storage: DatabasePrimitive, Coder: DatabaseValueAdapter>(
         at column: Int32,
-        using adapter: Coder.Type,
+        using adapter: Coder,
         storage: Storage.Type
     ) throws(OtterError) -> Coder.Value {
         let storage = try Storage(from: sqliteStatement, at: column)
@@ -50,7 +64,7 @@ public struct Row: ~Copyable {
     /// if it has a value.
     @inlinable public func optionalValue<Storage: DatabasePrimitive, Coder: DatabaseValueAdapter>(
         at column: Int32,
-        using adapter: Coder.Type,
+        using adapter: Coder,
         storage: Storage.Type
     ) throws(OtterError) -> Coder.Value? {
         guard let storage = try Storage?(from: sqliteStatement, at: column) else { return  nil}

Sources/Otter/Database.swift

@@ -9,8 +9,10 @@ import Foundation
 
 /// The base protocol every generated database conforms too.
 public protocol Database: ConnectionWrapper {
+    associatedtype Adapters
+    
     /// The connection to use
-    init(connection: any Connection)
+    init(connection: any Connection, adapters: Adapters)
     /// An ordered list of migrations to be run.
     static var migrations: [String] { get }
 }
@@ -19,22 +21,22 @@ public extension Database {
     /// Opens a connection pool to the database at the given URL.
     ///
     /// - Parameter url: The url of the database file
-    init(url: URL) throws {
-        self = try Self(path: url.path)
+    init(url: URL, adapters: Adapters) throws {
+        self = try Self(path: url.path, adapters: adapters)
     }
 
     /// Opens a connection pool to the database at the given path.
     ///
     /// - Parameter path: The path of the database file
-    init(path: String) throws {
-        self = try Self(config: DatabaseConfig(path: path))
+    init(path: String, adapters: Adapters) throws {
+        self = try Self(config: DatabaseConfig(path: path), adapters: adapters)
     }
 
     /// Opens a connection pool to the database
     ///
     /// - Parameter config: The configuration specifying any info
     /// needed to open the database.
-    init(config: DatabaseConfig) throws {
+    init(config: DatabaseConfig, adapters: Adapters) throws {
         let connection: any Connection = if let path = config.path {
             try ConnectionPool(
                 path: path,
@@ -49,11 +51,49 @@ public extension Database {
             )
         }
 
-        self = Self(connection: connection)
+        self = Self(connection: connection, adapters: adapters)
     }
 
+    /// Creates an in memory database.
+    static func inMemory(adapters: Adapters) throws -> Self {
+        return try Self(config: DatabaseConfig(path: nil), adapters: adapters)
+    }
+}
+
+
+extension Database where Adapters == DefaultAdapters {
     /// Creates an in memory database.
     static func inMemory() throws -> Self {
-        return try Self(config: DatabaseConfig(path: nil))
+        return try Self(config: DatabaseConfig(path: nil), adapters: DefaultAdapters())
     }
 }
+
+/// A marker protocol for the adapters for a database.
+/// Need a protocol so we can do extensions on the Database.Adapters
+public protocol Adapters: Sendable {}
+
+/// The default type for adapters when the database is generated
+/// if there are no adapters
+public struct DefaultAdapters: Adapters {
+    public init() {}
+}
+
+extension Adapters {
+    public var bool: BoolDatabaseValueAdapter { BoolDatabaseValueAdapter() }
+    public var int8: Int8DatabaseValueAdapter { Int8DatabaseValueAdapter() }
+    public var int16: Int16DatabaseValueAdapter { Int16DatabaseValueAdapter() }
+    public var int32: Int32DatabaseValueAdapter { Int32DatabaseValueAdapter() }
+    public var int64: Int64DatabaseValueAdapter { Int64DatabaseValueAdapter() }
+    public var uint8: UInt8DatabaseValueAdapter { UInt8DatabaseValueAdapter() }
+    public var uint16: UInt16DatabaseValueAdapter { UInt16DatabaseValueAdapter() }
+    public var uint32: UInt32DatabaseValueAdapter { UInt32DatabaseValueAdapter() }
+    public var uint64: UInt64DatabaseValueAdapter { UInt64DatabaseValueAdapter() }
+    public var uint: UIntDatabaseValueAdapter { UIntDatabaseValueAdapter() }
+    public var float: FloatDatabaseValueAdapter { FloatDatabaseValueAdapter() }
+    @available(macOS 11.0, *)
+    public var float16: Float16DatabaseValueAdapter { Float16DatabaseValueAdapter() }
+    public var uuid: UUIDDatabaseValueAdapter { UUIDDatabaseValueAdapter() }
+    public var decimal: DecimalDatabaseValueAdapter { DecimalDatabaseValueAdapter() }
+    public var date: DateDatabaseValueAdapter { DateDatabaseValueAdapter() }
+    public var url: URLDatabaseValueAdapter { URLDatabaseValueAdapter() }
+}