add the ability to subscript SQLRow by column name

Author: ahmedk92

Sources/SwiftSQL/SQLStatement.swift

@@ -242,6 +242,21 @@ public final class SQLStatement {
     public func columnName(at index: Int) -> String {
         String(cString: sqlite3_column_name(ref, Int32(index)))
     }
+    
+    // MARK: Indices from Names
+    
+    /// Returns the index of a column given its name.
+    public func columnIndex(forName name: String) -> Int? {
+        return columnIndices[name]
+    }
+    private lazy var columnIndices: [String : Int] = {
+        var indices: [String : Int] = [:]
+        indices.reserveCapacity(columnCount)
+        for index in 0..<columnCount {
+            indices[String(cString: sqlite3_column_name(ref, Int32(index)))] = index
+        }
+        return indices
+    }()
 
     // MARK: Reset
 

Sources/SwiftSQLExt/SwiftSQLExt.swift

@@ -20,6 +20,9 @@ public extension SQLStatement {
     func rows<T: SQLRowDecodable>(_ type: T.Type, count: Int? = nil) throws -> [T] {
         var objects = [T]()
         let limit = count ?? Int.max
+        if let count = count {
+            objects.reserveCapacity(count)
+        }
         while let object = try row(T.self), objects.count < limit {
             objects.append(object)
         }
@@ -60,6 +63,32 @@ public struct SQLRow {
     public subscript<T: SQLDataType>(index: Int) -> T? {
         statement.column(at: index)
     }
+    
+    /// Returns a single column (by its name) of the current result row of a query.
+    ///
+    /// If the SQL statement does not currently point to a valid row, the result is undefined.
+    /// If the passed columnName doesn't point to a valid column name, a fatal error is raised.
+    ///
+    /// - parameter columnName: The name of the column.
+    public subscript<T: SQLDataType>(columnName: String) -> T {
+        guard let columnIndex = statement.columnIndex(forName: columnName) else {
+            fatalError("No such column \(columnName)")
+        }
+        return statement.column(at: columnIndex)
+    }
+    
+    /// Returns a single column (by its name) of the current result row of a query.
+    ///
+    /// If the SQL statement does not currently point to a valid row, the result is undefined.
+    /// If the passed columnName doesn't point to a valid column name, nil is returned.
+    ///
+    /// - parameter columnName: The name of the column.
+    public subscript<T: SQLDataType>(columnName: String) -> T? {
+        guard let columnIndex = statement.columnIndex(forName: columnName) else {
+            return nil
+        }
+        return statement.column(at: columnIndex)
+    }
 }
 
 public protocol SQLRowDecodable {

Tests/SwiftSQLExtTests/SwiftSQLExtTests.swift

@@ -69,6 +69,21 @@ final class SwiftSQLExtTests: XCTestCase {
             User(name: "Alice", level: 80)
         ])
     }
+    
+    func testNamedSubscriptsSuccess() throws {
+        // GIVEN
+        try db.populateStore()
+
+        // WHEN
+        let persons = try db
+            .prepare("SELECT Name FROM Persons ORDER BY Level ASC")
+            .rows(Person.self, count: 1)
+
+        // THEN
+        XCTAssertEqual(persons, [
+            Person(name: "Alice", level: nil)
+        ])
+    }
 }
 
 private extension SQLConnection {
@@ -81,19 +96,42 @@ private extension SQLConnection {
             Level INTEGER
         )
         """)
+        try execute("""
+        CREATE TABLE Persons
+        (
+            Id INTEGER PRIMARY KEY NOT NULL,
+            Name VARCHAR,
+            Level INTEGER
+        )
+        """)
 
-        let statement = try self.prepare("""
+        let insertUsersStatement = try self.prepare("""
         INSERT INTO Users (Name, Level)
         VALUES (?, ?)
         """)
 
-        try statement
+        try insertUsersStatement
             .bind("Alice", Int64(80))
             .execute()
 
-        try statement.reset()
+        try insertUsersStatement.reset()
 
-        try statement
+        try insertUsersStatement
+            .bind("Bob", Int64(90))
+            .execute()
+        
+        let insertPersonsStatement = try self.prepare("""
+        INSERT INTO Persons (Name, Level)
+        VALUES (?, ?)
+        """)
+
+        try insertPersonsStatement
+            .bind("Alice", Int64(80))
+            .execute()
+
+        try insertPersonsStatement.reset()
+
+        try insertPersonsStatement
             .bind("Bob", Int64(90))
             .execute()
     }
@@ -114,3 +152,17 @@ private struct User: Hashable, SQLRowDecodable {
         self.level = row[1]
     }
 }
+private struct Person: Hashable, SQLRowDecodable {
+    let name: String
+    let level: Int64?
+
+    init(name: String, level: Int64?) {
+        self.name = name
+        self.level = level
+    }
+
+    init(row: SQLRow) throws {
+        self.name = row["Name"]
+        self.level = row["Level"]
+    }
+}