Merge pull request #16 from Alexander-Ignition/swift-6.2

Swift 6.2

Author: Alexander-Ignition

.github/workflows/test.yml

@@ -24,7 +24,7 @@ on:
 jobs:
   Apple:
     name: Test ${{ matrix.name }}
-    runs-on: macOS-latest
+    runs-on: macOS-26
     strategy:
       fail-fast: false
       matrix:
@@ -41,7 +41,7 @@ jobs:
         shell: bash
   SPM:
     name: Test with SPM
-    runs-on: macOS-latest
+    runs-on: macos-26
     steps:
       - name: Checkout
         uses: actions/checkout@v4

Makefile

@@ -27,16 +27,16 @@ test:
 test-macos: $(OUTPUD_DIR)/test-macos.xcresult
 test-ios: $(OUTPUD_DIR)/test-ios.xcresult
 
-XCODEBUILD_TEST = xcodebuild test -quiet -scheme $(TARGET_NAME)
-XCCOV = xcrun xccov view --files-for-target $(TARGET_NAME)
+XCODEBUILD_TEST = xcodebuild test -quiet -scheme $(TARGET_NAME) -resultBundlePath $@
+XCCOV = xcrun xccov view --files-for-target $(TARGET_NAME) --report $@
 
 $(OUTPUD_DIR)/test-macos.xcresult:
-	$(XCODEBUILD_TEST) -destination 'platform=macOS' -resultBundlePath $@
-	$(XCCOV) --report $@
+	$(XCODEBUILD_TEST) -destination 'platform=macOS'
+	$(XCCOV)
 
 $(OUTPUD_DIR)/test-ios.xcresult:
-	$(XCODEBUILD_TEST) -destination 'platform=iOS Simulator,name=iPhone 16' -resultBundlePath $@
-	$(XCCOV) --report $@
+	$(XCODEBUILD_TEST) -destination 'platform=iOS Simulator,name=iPhone 17'
+	$(XCCOV)
 
 # Apple Containerization or Docker
 CONTAINER ?= container

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.9
+// swift-tools-version:6.2
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -30,7 +30,11 @@ let package = Package(
         ),
         .systemLibrary(
             name: "SQLite3",
-            pkgConfig: "sqlite3"
+            pkgConfig: "sqlite3",
+            providers: [
+                .apt(["libsqlite3-dev"]),
+                .brew(["sqlite3"]),
+            ]
         ),
         .testTarget(
             name: "SQLyraTests",

Sources/SQLyra/DataFrame.swift

@@ -45,7 +45,9 @@ extension PreparedStatement {
         while let row = try row() {
             df.appendEmptyRow()
             for index in (0..<columnCount) {
-                df.rows[count][index] = row[index].flatMap { valueTransformers[index].transform($0) }
+                if let value = row[index] {
+                    df.rows[count][index] = valueTransformers[index].transform(value)
+                }
             }
             count += 1
         }
@@ -73,10 +75,10 @@ public struct ColumnValueTransformer: Sendable {
     @usableFromInline
     let column: @Sendable (_ name: String, _ capacity: Int) -> AnyColumn
     @usableFromInline
-    let transform: @Sendable (PreparedStatement.Value) -> Any?
+    let transform: @Sendable (borrowing PreparedStatement.Value) -> Any?
 
     @inlinable
-    public init<T>(transform: @escaping @Sendable (PreparedStatement.Value) -> T?) {
+    public init<T>(transform: @escaping @Sendable (borrowing PreparedStatement.Value) -> T?) {
         self.column = { name, capacity in
             TabularData.Column<T>(name: name, capacity: capacity).eraseToAnyColumn()
         }

Sources/SQLyra/PreparedStatement.swift

@@ -201,62 +201,73 @@ extension PreparedStatement {
     }
 
     @dynamicMemberLookup
-    public struct Row {
+    public struct Row: ~Copyable {
         let statement: PreparedStatement
 
         public subscript(dynamicMember name: String) -> Value? {
             self[name]
         }
 
-        public subscript(name: String) -> Value? {
-            statement.columnIndexByName[name].flatMap { self[$0] }
+        public subscript(columnName: String) -> Value? {
+            statement.columnIndexByName[columnName].flatMap { self[$0] }
         }
 
-        public subscript(index: Int) -> Value? {
-            if sqlite3_column_type(statement.stmt, Int32(index)) == SQLITE_NULL {
-                return nil
-            }
-            return Value(index: Int32(index), statement: statement)
+        public subscript(columnIndex: Int) -> Value? {
+            statement.value(at: columnIndex)
+        }
+
+        public func decode<T>(_ type: T.Type, using decoder: RowDecoder? = nil) throws -> T where T: Decodable {
+            try (decoder ?? RowDecoder.default).decode(type, from: self)
         }
+    }
 
-        public func decode<T>(_ type: T.Type) throws -> T where T: Decodable {
-            try decode(type, using: RowDecoder.default)
+    func null(for columnName: String) -> Bool {
+        guard let columnIndex = columnIndexByName[columnName] else {
+            return true
         }
+        return null(at: columnIndex)
+    }
+
+    private func null(at columnIndex: Int) -> Bool {
+        sqlite3_column_type(stmt, Int32(columnIndex)) == SQLITE_NULL
+    }
 
-        public func decode<T>(_ type: T.Type, using decoder: RowDecoder) throws -> T where T: Decodable {
-            try decoder.decode(type, from: self)
+    func value(at columnIndex: Int) -> Value? {
+        if null(at: columnIndex) {
+            return nil
         }
+        return Value(columnIndex: Int32(columnIndex), statement: self)
     }
 
     /// Result value from a query.
-    public struct Value {
-        let index: Int32
+    public struct Value: ~Copyable {
+        let columnIndex: Int32
         let statement: PreparedStatement
         private var stmt: OpaquePointer { statement.stmt }
 
         /// 64-bit INTEGER result.
-        public var int64: Int64 { sqlite3_column_int64(stmt, index) }
+        public var int64: Int64 { sqlite3_column_int64(stmt, columnIndex) }
 
         /// 32-bit INTEGER result.
-        public var int32: Int32 { sqlite3_column_int(stmt, index) }
+        public var int32: Int32 { sqlite3_column_int(stmt, columnIndex) }
 
         /// A platform-specific integer.
         public var int: Int { Int(int64) }
 
         /// 64-bit IEEE floating point number.
-        public var double: Double { sqlite3_column_double(stmt, index) }
+        public var double: Double { sqlite3_column_double(stmt, columnIndex) }
 
         /// Size of a BLOB or a UTF-8 TEXT result in bytes.
-        public var count: Int { Int(sqlite3_column_bytes(stmt, index)) }
+        public var count: Int { Int(sqlite3_column_bytes(stmt, columnIndex)) }
 
         /// UTF-8 TEXT result.
         public var string: String? {
-            sqlite3_column_text(stmt, index).flatMap { String(cString: $0) }
+            sqlite3_column_text(stmt, columnIndex).flatMap { String(cString: $0) }
         }
 
         /// BLOB result.
         public var blob: Data? {
-            sqlite3_column_blob(stmt, index).map { Data(bytes: $0, count: count) }
+            sqlite3_column_blob(stmt, columnIndex).map { Data(bytes: $0, count: count) }
         }
     }
 }

Sources/SQLyra/RowDecoder.swift

@@ -1,5 +1,3 @@
-import SQLite3
-
 #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
 import Foundation
 #else
@@ -16,14 +14,22 @@ public final class RowDecoder {
     /// Creates a new, reusable row decoder.
     public init() {}
 
-    public func decode<T>(_ type: T.Type, from row: PreparedStatement.Row) throws -> T where T: Decodable {
-        let decoder = _RowDecoder(row: row, userInfo: userInfo)
+    public func decode<T>(
+        _ type: T.Type,
+        from row: borrowing PreparedStatement.Row
+    ) throws -> T where T: Decodable {
+        let decoder = _RowDecoder(statement: row.statement, userInfo: userInfo)
         return try type.init(from: decoder)
     }
 }
 
-private struct _RowDecoder: Decoder {
-    let row: PreparedStatement.Row
+private final class _RowDecoder: Decoder {
+    let statement: PreparedStatement
+
+    init(statement: PreparedStatement, userInfo: [CodingUserInfoKey: Any]) {
+        self.statement = statement
+        self.userInfo = userInfo
+    }
 
     // MARK: - Decoder
 
@@ -47,9 +53,9 @@ private struct _RowDecoder: Decoder {
     struct KeyedContainer<Key: CodingKey>: KeyedDecodingContainerProtocol {
         let decoder: _RowDecoder
         var codingPath: [any CodingKey] { decoder.codingPath }
-        var allKeys: [Key] { decoder.row.statement.columnIndexByName.keys.compactMap { Key(stringValue: $0) } }
+        var allKeys: [Key] { decoder.statement.columnIndexByName.keys.compactMap { Key(stringValue: $0) } }
 
-        func contains(_ key: Key) -> Bool { decoder.row.statement.columnIndexByName.keys.contains(key.stringValue) }
+        func contains(_ key: Key) -> Bool { decoder.statement.columnIndexByName.keys.contains(key.stringValue) }
         func decodeNil(forKey key: Key) throws -> Bool { decoder.null(for: key) }
         func decode(_ type: Bool.Type, forKey key: Key) throws -> Bool { try decoder.bool(forKey: key) }
         func decode(_ type: String.Type, forKey key: Key) throws -> String { try decoder.string(forKey: key) }
@@ -84,7 +90,7 @@ private struct _RowDecoder: Decoder {
 
     @inline(__always)
     func null<K>(for key: K) -> Bool where K: CodingKey {
-        row[key.stringValue] == nil
+        statement.null(for: key.stringValue)
     }
 
     @inline(__always)
@@ -131,13 +137,13 @@ private struct _RowDecoder: Decoder {
 
     @inline(__always)
     private func columnValue<T, K>(_ type: T.Type, forKey key: K) throws -> PreparedStatement.Value where K: CodingKey {
-        guard let index = row.statement.columnIndexByName[key.stringValue] else {
+        guard let index = statement.columnIndexByName[key.stringValue] else {
             throw DecodingError.keyNotFound(key, .context([key], "Column index not found for key: \(key)"))
         }
-        guard let column = row[index] else {
+        guard let value = statement.value(at: index) else {
             throw DecodingError.valueNotFound(type, .context([key], "Column value not found for key: \(key)"))
         }
-        return column
+        return value
     }
 }
 
@@ -151,11 +157,11 @@ private struct _ValueDecoder: Decoder, SingleValueDecodingContainer {
     var codingPath: [any CodingKey] { [key] }
 
     func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key: CodingKey {
-        throw DecodingError.typeMismatch(PreparedStatement.Value.self, .context(codingPath, ""))
+        throw DecodingError.dataCorrupted(.context(codingPath, ""))
     }
 
     func unkeyedContainer() throws -> any UnkeyedDecodingContainer {
-        throw DecodingError.typeMismatch(PreparedStatement.Value.self, .context(codingPath, ""))
+        throw DecodingError.dataCorrupted(.context(codingPath, ""))
     }
 
     func singleValueContainer() throws -> any SingleValueDecodingContainer {

Tests/SQLyraTests/DatabaseTests.swift

@@ -8,66 +8,67 @@ import Foundation
 import FoundationEssentials
 #endif
 
-@Test func openOptionsRawValue() {
-    typealias Options = Database.OpenOptions
-    #expect(Options.create.rawValue == SQLITE_OPEN_CREATE)
-    #expect(Options.readwrite.rawValue == SQLITE_OPEN_READWRITE)
-    #expect(Options.readonly.rawValue == SQLITE_OPEN_READONLY)
-    #expect(Options.memory.rawValue == SQLITE_OPEN_MEMORY)
-    #expect(Options.extendedResultCode.rawValue == SQLITE_OPEN_EXRESCODE)
-    #expect(Options.uri.rawValue == SQLITE_OPEN_URI)
-    #expect(Options.noFollow.rawValue == SQLITE_OPEN_NOFOLLOW)
-    #expect(Options.noMutex.rawValue == SQLITE_OPEN_NOMUTEX)
-    #expect(Options.fullMutex.rawValue == SQLITE_OPEN_FULLMUTEX)
-    #expect(Options.sharedCache.rawValue == SQLITE_OPEN_SHAREDCACHE)
-    #expect(Options.privateCache.rawValue == SQLITE_OPEN_PRIVATECACHE)
+extension Database.OpenOptions: CustomTestStringConvertible {
+    public var testDescription: String {
+        String(rawValue, radix: 16, uppercase: true)
+    }
 }
 
 struct DatabaseTests {
-    private let fileManager = FileManager.default
-    private let path = "Tests/new.db"
 
-    init() {
-        #if Xcode  // for relative path
-        fileManager.changeCurrentDirectoryPath(#file.components(separatedBy: "/Tests")[0])
-        #endif
+    @Test(arguments: [
+        (Database.OpenOptions.create, SQLITE_OPEN_CREATE),
+        (Database.OpenOptions.readwrite, SQLITE_OPEN_READWRITE),
+        (Database.OpenOptions.readonly, SQLITE_OPEN_READONLY),
+        (Database.OpenOptions.memory, SQLITE_OPEN_MEMORY),
+        (Database.OpenOptions.extendedResultCode, SQLITE_OPEN_EXRESCODE),
+        (Database.OpenOptions.uri, SQLITE_OPEN_URI),
+        (Database.OpenOptions.noFollow, SQLITE_OPEN_NOFOLLOW),
+        (Database.OpenOptions.noMutex, SQLITE_OPEN_NOMUTEX),
+        (Database.OpenOptions.fullMutex, SQLITE_OPEN_FULLMUTEX),
+        (Database.OpenOptions.sharedCache, SQLITE_OPEN_SHAREDCACHE),
+        (Database.OpenOptions.privateCache, SQLITE_OPEN_PRIVATECACHE),
+    ])
+    func open(options: Database.OpenOptions, expected: Int32) {
+        #expect(options.rawValue == expected)
     }
 
     @Test func open() throws {
-        let url = URL(fileURLWithPath: path)
-        var database: Database! = try Database.open(at: path, options: [.readwrite, .create])
+        let fileManager = FileManager.default
+        try #require(fileManager.changeCurrentDirectoryPath(fileManager.temporaryDirectory.path))
+        let url = URL(fileURLWithPath: "SQLyra.db", isDirectory: false)
         defer {
-            database = nil  // closing before remove a file
+            // closing database before remove a file
             #expect(throws: Never.self) { try fileManager.removeItem(at: url) }
         }
-        #expect(!database.isReadonly)
-        #expect(database.filename == url.path)
-        #expect(fileManager.fileExists(atPath: url.path))
+        do {
+            let database = try Database.open(at: "SQLyra.db", options: [.readwrite, .create])
+            #expect(!database.isReadonly)
+            #expect(database.filename == url.path)
+            #expect(fileManager.fileExists(atPath: url.path))
+        }
     }
 
-    @Test func openError() throws {
-        do {
-            let database = try Database.open(at: path, options: [])
-            Issue.record("no error \(database)")
-        } catch let error {  // DatabaseError
-            #expect(error.code == SQLITE_MISUSE)
+    @Test func openError() {
+        #expect(throws: DatabaseError.self) {
+            try Database.open(at: "db.sqlite", options: [])
         }
     }
 
     @Test func memory() throws {
-        let database = try Database.open(at: path, options: [.readwrite, .memory])
+        let database = try Database.open(at: ":memory:", options: [.readwrite, .memory])
         #expect(!database.isReadonly)
         #expect(database.filename == "")
     }
 
     @Test func readonly() throws {
-        let database = try Database.open(at: path, options: [.readonly, .memory])
+        let database = try Database.open(at: ":memory:", options: [.readonly, .memory])
         #expect(database.isReadonly)
         #expect(database.filename == "")
     }
 
     @Test func execute() throws {
-        let database = try Database.open(at: path, options: [.readwrite, .memory])
+        let database = try Database.open(at: ":memory:", options: [.readwrite, .memory])
 
         let sql = """
             CREATE TABLE contacts(id INT PRIMARY KEY NOT NULL, name TEXT);