Merge pull request #6 from ahmedk92/sqlrow-true-value-semantics-any

SQLRow true value semantics with Any

Author: kean

Sources/SwiftSQL/SQLDataType.swift

@@ -14,6 +14,10 @@ public protocol SQLDataType {
     static func sqlColumn(statement: OpaquePointer, index: Int32) -> Self
 }
 
+public extension SQLDataType {
+    static func convert(from value: Any) -> Self? { value as? Self }
+}
+
 extension Int: SQLDataType {
     public func sqlBind(statement: OpaquePointer, index: Int32) {
         sqlite3_bind_int64(statement, index, Int64(self))

Sources/SwiftSQL/SQLStatement.swift

@@ -223,6 +223,28 @@ public final class SQLStatement {
             return T.sqlColumn(statement: ref, index: Int32(index))
         }
     }
+    
+    public func column(at index: Int) -> Any? {
+        let index = Int32(index)
+        let type = sqlite3_column_type(ref, index)
+        switch type {
+            case SQLITE_INTEGER:
+                return sqlite3_column_int64(ref, index)
+            case SQLITE_FLOAT:
+                return sqlite3_column_double(ref, index)
+            case SQLITE_TEXT:
+                return String(cString: sqlite3_column_text(ref, index))
+            case SQLITE_BLOB:
+                if let bytes = sqlite3_column_blob(ref, index) {
+                    let byteCount = sqlite3_column_bytes(ref, index)
+                    return Data(bytes: bytes, count: Int(byteCount))
+                } else {
+                    return Data()
+                }
+            default:
+                return nil
+        }
+    }
 
     /// Return the number of columns in the result set returned by the statement.
     ///

Sources/SwiftSQLExt/SwiftSQLExt.swift

@@ -28,19 +28,40 @@ public extension SQLStatement {
         }
         return objects
     }
+    
+    /// Fetches the next row as `SQLRow`.
+    func row() throws -> SQLRow? {
+        guard try step() else {
+            return nil
+        }
+        return SQLRow(statement: self)
+    }
+
+    /// Fetches the first `count` rows as `SQLRow`s returned by the statement. By default,
+    /// fetches all rows.
+    func rows(count: Int? = nil) throws -> [SQLRow] {
+        var objects = [SQLRow]()
+        let limit = count ?? Int.max
+        if let count = count {
+            objects.reserveCapacity(count)
+        }
+        while let object = try row(), objects.count < limit {
+            objects.append(object)
+        }
+        return objects
+    }
 }
 
 /// Represents a single row returned by the SQL statement.
-///
-/// - warning: This is a leaky abstraction. This is not a real value type, it
-/// just wraps the underlying statement. If the statement moves to the next
-/// row by calling `step()`, the row is also going to point to the new row.
 public struct SQLRow {
-    /// The underlying statement.
-    public let statement: SQLStatement // Storing as strong reference doesn't seem to affect performance
 
     public init(statement: SQLStatement) {
-        self.statement = statement
+        values = (0..<statement.columnCount).map { index in
+            statement.column(at: index)
+        }
+        columnIndicesByNames = Dictionary(uniqueKeysWithValues: (0..<statement.columnCount).map { index in
+            (statement.columnName(at: index), index)
+        })
     }
 
     /// Returns a single column of the current result row of a query.
@@ -50,7 +71,7 @@ public struct SQLRow {
     ///
     /// - parameter index: The leftmost column of the result set has the index 0.
     public subscript<T: SQLDataType>(index: Int) -> T {
-        statement.column(at: index)
+        T.convert(from: values[index]!)!
     }
 
     /// Returns a single column of the current result row of a query. If the
@@ -61,7 +82,8 @@ public struct SQLRow {
     ///
     /// - parameter index: The leftmost column of the result set has the index 0.
     public subscript<T: SQLDataType>(index: Int) -> T? {
-        statement.column(at: index)
+        guard let value = values[index] else { return nil }
+        return T.convert(from: value)
     }
 
     /// Returns a single column (by its name) of the current result row of a query.
@@ -71,10 +93,10 @@ public struct SQLRow {
     ///
     /// - parameter columnName: The name of the column.
     public subscript<T: SQLDataType>(columnName: String) -> T {
-        guard let columnIndex = statement.columnIndex(forName: columnName) else {
+        guard let columnIndex = columnIndicesByNames[columnName] else {
             fatalError("No such column \(columnName)")
         }
-        return statement.column(at: columnIndex)
+        return self[columnIndex]
     }
 
     /// Returns a single column (by its name) of the current result row of a query.
@@ -84,11 +106,14 @@ public struct SQLRow {
     ///
     /// - parameter columnName: The name of the column.
     public subscript<T: SQLDataType>(columnName: String) -> T? {
-        guard let columnIndex = statement.columnIndex(forName: columnName) else {
+        guard let columnIndex = columnIndicesByNames[columnName] else {
             return nil
         }
-        return statement.column(at: columnIndex)
+        return self[columnIndex]
     }
+    
+    private let values: [Any?]
+    private let columnIndicesByNames: [String : Int]
 }
 
 public protocol SQLRowDecodable {

Tests/SwiftSQLExtTests/SwiftSQLExtTests.swift

@@ -70,20 +70,50 @@ final class SwiftSQLExtTests: XCTestCase {
         ])
     }
 
-    func testNamedSubscriptsSuccess() throws {
+    func testIndependentSQLRows() throws {
         // GIVEN
         try db.populateStore()
 
         // WHEN
-        let persons = try db
+        let names: [String] = try db
             .prepare("SELECT Name FROM Persons ORDER BY Level ASC")
-            .rows(Person.self, count: 1)
+            .rows()
+            .map({ $0["Name"] })
 
         // THEN
-        XCTAssertEqual(persons, [
-            Person(name: "Alice", level: nil)
+        XCTAssertEqual(names, [
+            "Alice",
+            "Bob"
         ])
     }
+    
+    func testIndependentSingleSQLRowNonNil() throws {
+        // GIVEN
+        try db.populateStore()
+
+        // WHEN
+        let row = try db
+            .prepare("SELECT Name FROM Persons ORDER BY Level ASC")
+            .row()
+
+        // THEN
+        XCTAssertEqual(try XCTUnwrap(row)["Name"] as String, "Alice")
+    }
+    
+    func testIndependentSingleSQLRowNil() throws {
+        // GIVEN
+        try db.populateStore()
+
+        // WHEN
+        let row = try db
+            .prepare("SELECT Name FROM Persons ORDER BY Level ASC")
+            .row()
+
+        // THEN
+        XCTAssertNil(try XCTUnwrap(row)["Level"] as Int?)
+    }
+    
+    
 }
 
 private extension SQLConnection {