custom aliased encoding

Author: wickwirew

Sources/Compiler/Gen/Language.swift

@@ -109,14 +109,25 @@ extension Language {
                 let type = column.value
                 fields[name] = GeneratedField(
                     name: name,
-                    type: .builtin(builtinType(for: type), isArray: false),
+                    type: .builtin(
+                        builtinType(for: type),
+                        isArray: false,
+                        encodedAs: builtinForAliasedType(for: type)
+                    ),
                     isArray: type.isRow
                 )
             },
             isTable: true
         )
     }
 
+    /// If the column type was aliased then this will return the `builtin`
+    /// type for the root type of the alias.
+    private static func builtinForAliasedType(for type: Type) -> String? {
+        guard case let .alias(root, _) = type else { return nil }
+        return builtinType(for: root)
+    }
+    
     private static func inputTypeIfNeeded(
         statement: Statement,
         definition: Definition
@@ -126,7 +137,8 @@ extension Language {
         guard statement.parameters.count > 1 else {
             return .builtin(
                 builtinType(for: firstParameter.type),
-                isArray: firstParameter.type.isRow
+                isArray: firstParameter.type.isRow,
+                encodedAs: builtinForAliasedType(for: firstParameter.type)
             )
         }
 
@@ -137,7 +149,11 @@ extension Language {
             fields: statement.parameters.reduce(into: [:]) { fields, parameter in
                 fields[parameter.name] = GeneratedField(
                     name: parameter.name,
-                    type: .builtin(builtinType(for: parameter.type), isArray: false),
+                    type: .builtin(
+                        builtinType(for: parameter.type),
+                        isArray: false,
+                        encodedAs: builtinForAliasedType(for: parameter.type)
+                    ),
                     isArray: parameter.type.isRow
                 )
             },
@@ -168,7 +184,11 @@ extension Language {
 
         // Only one column returned, just use it's type
         guard statement.resultColumns.count > 1 else {
-            return .builtin(builtinType(for: firstColumn), isArray: firstColumn.isRow)
+            return .builtin(
+                builtinType(for: firstColumn),
+                isArray: firstColumn.isRow,
+                encodedAs: builtinForAliasedType(for: firstColumn)
+            )
         }
 
         let outputTypeName = definition.output?.description ?? "\(definition.name.capitalizedFirst)Output"
@@ -189,7 +209,11 @@ extension Language {
                         let type = column.value
                         fields[name] = GeneratedField(
                             name: name,
-                            type: .builtin(builtinType(for: type), isArray: false),
+                            type: .builtin(
+                                builtinType(for: type),
+                                isArray: false,
+                                encodedAs: builtinForAliasedType(for: type)
+                            ),
                             isArray: type.isRow
                         )
                     }
@@ -217,9 +241,21 @@ public struct GeneratedModel {
 }
 
 public struct GeneratedField {
+    /// The column name
     let name: String
+    /// The type of the field.
+    /// If it is a `model` that means the user selected
+    /// all columns from a table `foo.*`
     let type: BuiltinOrGenerated
+    /// Whether or not it is an array. Some fields can take a list
+    /// as an input for a query like `foo IN :bar`
     let isArray: Bool
+    
+    /// The underlying storage type if it is aliased
+    var encodedAsType: String? {
+        guard case let .builtin(_, _, encodedAs) = type else { return nil }
+        return encodedAs
+    }
 }
 
 public struct GeneratedQuery {
@@ -239,12 +275,17 @@ public struct GeneratedResult<Decl> {
 }
 
 public enum BuiltinOrGenerated: CustomStringConvertible {
-    case builtin(String, isArray: Bool)
+    /// Types can be aliased. So `TEXT AS UUID`. `encodedAs`
+    /// would be the `TEXT`. It will allow us to tell the
+    /// `bind` functions to actually encode to the underlying
+    /// type rather than just having `UUID` always go to `TEXT`
+    /// when some users may want a `BLOB`.
+    case builtin(String, isArray: Bool, encodedAs: String?)
     case model(GeneratedModel)
 
     public var description: String {
         switch self {
-        case .builtin(let builtin, let isArray):
+        case .builtin(let builtin, let isArray, _):
             isArray ? "[\(builtin)]" : builtin
         case .model(let model):
             model.name

Sources/Compiler/Gen/SwiftLanguage.swift

@@ -21,6 +21,7 @@ public struct SwiftLanguage: Language {
             case "INT": "Int"
             case "INTEGER": "Int"
             case "TEXT": "String"
+            case "BLOB": "Data"
             default: "Any"
             }
         case let .optional(ty): "\(builtinType(for: ty))?"
@@ -175,11 +176,11 @@ public struct SwiftLanguage: Language {
 
                     if let input = query.input {
                         switch input {
-                        case let .builtin(_, isArray):
-                            bind(field: nil, isArray: isArray)
+                        case let .builtin(_, isArray, encodedAs):
+                            bind(field: nil, encodeToType: encodedAs, isArray: isArray)
                         case .model(let model):
                             for field in model.fields.values {
-                                bind(field: field.name, isArray: field.isArray)
+                                bind(field: field.name, encodeToType: field.encodedAsType, isArray: field.isArray)
                             }
                         }
                     }
@@ -323,8 +324,13 @@ public struct SwiftLanguage: Language {
             var index = 0
             for field in model.fields.values {
                 switch field.type {
-                case .builtin:
-                    "self.\(raw: field.name) = try row.value(at: start + \(raw: index))"
+                case .builtin(_, _, let encodedAs):
+                    if let encodedAs {
+                        "self.\(raw: field.name) = try \(raw: field.type)(primitive: row.value(at: start + \(raw: index), as: \(raw: encodedAs).self))"
+                    } else {
+                        "self.\(raw: field.name) = try row.value(at: start + \(raw: index))"
+                    }
+
                     let _ = index += 1
                 case .model(let model):
                     "self.\(raw: field.name) = try \(raw: field.type)(row: row, startingAt: start + \(raw: index))"
@@ -416,6 +422,7 @@ public struct SwiftLanguage: Language {
     @CodeBlockItemListBuilder
     private static func bind(
         field: String?,
+        encodeToType: String?,
         isArray: Bool
     ) -> CodeBlockItemListSyntax {
         let paramName = if let field {
@@ -424,14 +431,20 @@ public struct SwiftLanguage: Language {
             "input"
         }
 
+        let encode = if let encodeToType {
+            ".encodeTo\(encodeToType)()"
+        } else {
+            ""
+        }
+        
         if isArray {
             """
             for element in \(raw: paramName) {
-                try statement.bind(value: element)
+                try statement.bind(value: element\(raw: encode))
             }
             """
         } else {
-            "try statement.bind(value: \(raw: paramName))"
+            "try statement.bind(value: \(raw: paramName)\(raw: encode))"
         }
     }
 }

Sources/Feather/ConnectionPool.swift

@@ -139,6 +139,9 @@ extension ConnectionPool: Connection {
         // tx functions consuming. Cause we cannot call `commit` in
         // the `do` and on failure call `rollback` since it would
         // have been consumed in the `commit`.
+        //
+        // Keeping them is consuming is nice since it stops callers
+        // from calling `commit` manually since its borrowed
         let result = Result {
             try execute(tx)
         }

Sources/Feather/Cursor.swift

@@ -27,39 +27,12 @@ public struct Cursor<Element: RowDecodable>: ~Copyable {
 }
 
 public struct Row: ~Copyable {
-    let sqliteStatement: OpaquePointer
+    @usableFromInline let sqliteStatement: OpaquePointer
 
-    public func value<Value: DatabasePrimitive>(at column: Int32) throws(FeatherError) -> Value {
+    @inlinable public func value<Value: DatabasePrimitive>(
+        at column: Int32,
+        as _: Value.Type = Value.self
+    ) throws(FeatherError) -> Value {
         return try Value(from: sqliteStatement, at: column)
     }
-    
-    /// Gets an interator to enumerate all of the columns for the `Row`
-    public func columnIterator() -> ColumnIterator {
-        return ColumnIterator(sqliteStatement)
-    }
-    
-    /// Will iterate over the columns. Returning the next column
-    /// in the row. Starts at column 0.
-    public struct ColumnIterator: ~Copyable {
-        @usableFromInline var sqliteStatement: OpaquePointer
-        /// The next column index to read. These indices start
-        /// with 0, unlike bind params starting at 1
-        @usableFromInline var column: Int32 = 0
-        @usableFromInline let count: Int32
-        
-        init(_ sqliteStatement: OpaquePointer) {
-            self.sqliteStatement = sqliteStatement
-            self.count = sqlite3_column_count(sqliteStatement)
-        }
-        
-        @inlinable public mutating func next<Value: DatabasePrimitive>() throws(FeatherError) -> Value {
-            guard column < count else {
-                throw .noMoreColumns
-            }
-            
-            let value = try Value(from: sqliteStatement, at: column)
-            column += 1
-            return value
-        }
-    }
 }

Sources/Feather/DatabasePrimitive.swift

@@ -45,16 +45,6 @@ extension Int: DatabasePrimitive {
     }
 }
 
-extension UInt: DatabasePrimitive {
-    @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
-        self = try UInt(bitPattern: Int(from: cursor, at: index))
-    }
-
-    @inlinable public func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError) {
-        sqlite3_bind_int(statement, index, Int32(bitPattern: UInt32(self)))
-    }
-}
-
 extension Double: DatabasePrimitive {
     @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
         self = sqlite3_column_double(cursor, index)
@@ -65,23 +55,16 @@ extension Double: DatabasePrimitive {
     }
 }
 
-extension Float: DatabasePrimitive {
-    @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
-        self = Float(sqlite3_column_double(cursor, index))
-    }
-
-    @inlinable public func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError) {
-        sqlite3_bind_double(statement, index, Double(self))
-    }
-}
-
-extension Bool: DatabasePrimitive {
+extension Data: DatabasePrimitive {
     @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
-        self = sqlite3_column_int64(cursor, index) == 1
+        let count = Int(sqlite3_column_bytes(cursor, index))
+        self = Data(bytes: sqlite3_column_blob(cursor, index), count: count)
     }
 
     @inlinable public func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError) {
-        sqlite3_bind_int(statement, index, self ? 1 : 0)
+        _ = withUnsafeBytes {
+            sqlite3_bind_blob(statement, index, $0.baseAddress, CInt($0.count), SQLITE_TRANSIENT)
+        }
     }
 }
 
@@ -102,21 +85,3 @@ extension Optional: DatabasePrimitive where Wrapped: DatabasePrimitive {
         }
     }
 }
-
-extension UUID: DatabasePrimitive {
-    @inlinable public init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError) {
-        guard let ptr = sqlite3_column_text(cursor, index) else {
-            throw .columnIsNil(index)
-        }
-
-        guard let value = UUID(uuidString: String(cString: ptr)) else {
-            throw .invalidUuidString
-        }
-        
-        self = value
-    }
-
-    @inlinable public func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError) {
-        try uuidString.bind(to: statement, at: index)
-    }
-}