Reuse CursorWithBindingArray to fix step issue

Author: miku1958

Sources/SQLite/Core/Statement.swift

@@ -291,6 +291,41 @@ extension CursorProtocol {
 	}
 }
 
+struct CursorWithBindingArray: CursorProtocol {
+	let elements: [Binding?]
+	init(elements: [Binding?]) {
+		self.elements = elements
+	}
+
+	func getValue(_ idx: Int) throws -> Binding? {
+		elements[idx]
+	}
+	func getValue(_ idx: Int) throws -> Double {
+		guard let value = elements[idx] as? Double else {
+			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
+		}
+		return value
+	}
+	func getValue(_ idx: Int) throws -> Int64 {
+		guard let value = elements[idx] as? Int64 else {
+			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
+		}
+		return value
+	}
+	func getValue(_ idx: Int) throws -> String {
+		guard let value = elements[idx] as? String else {
+			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
+		}
+		return value
+	}
+	func getValue(_ idx: Int) throws -> Blob {
+		guard let value = elements[idx] as? Blob else {
+			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
+		}
+		return value
+	}
+}
+
 public struct Cursor: CursorProtocol {
     fileprivate let statement: Statement
 	fileprivate var handle: OpaquePointer {

Sources/SQLite/Typed/Query+Lazy.swift

@@ -0,0 +1,57 @@
+//
+// SQLite.swift
+// https://github.com/stephencelis/SQLite.swift
+// Copyright © 2014-2015 Stephen Celis.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+extension Array where Element == LazySequence<AnyIterator<Row>> {
+	@available(swift, deprecated: 1, message: "Please use return value of prepare as Array directly")
+	public init(_ values: Element) {
+		preconditionFailure("Please use return value of prepare as Array directly")
+	}
+}
+
+extension Connection {
+	@_disfavoredOverload
+	public func prepare(_ query: QueryType) throws -> [Row] {
+		let expression = query.expression
+		let statement = try prepare(expression.template, expression.bindings)
+
+		let columnNames = try columnNamesForQuery(query)
+
+		return Array(AnyIterator {
+			statement.next().map { cursor in
+				Row(columnNames, (0..<columnNames.count).map({
+					try? cursor.getValue($0) as Binding?
+				}))
+			}
+		})
+	}
+
+	public func prepare(_ query: QueryType) throws -> LazySequence<AnyIterator<Row>> {
+		let expression = query.expression
+		let statement = try prepare(expression.template, expression.bindings)
+
+		let columnNames = try columnNamesForQuery(query)
+
+		return AnyIterator { statement.next().map { Row(columnNames, $0) } }.lazy
+	}
+}

Sources/SQLite/Typed/Query.swift

@@ -1003,16 +1003,6 @@ public struct RowIterator: FailableIterator {
 }
 
 extension Connection {
-
-    public func prepare(_ query: QueryType) throws -> LazySequence<AnyIterator<Row>> {
-        let expression = query.expression
-        let statement = try prepare(expression.template, expression.bindings)
-
-        let columnNames = try columnNamesForQuery(query)
-
-		return AnyIterator { statement.next().map { Row(columnNames, $0) } }.lazy
-    }
-
     public func prepareRowIterator(_ query: QueryType) throws -> RowIterator {
         let expression = query.expression
         let statement = try prepare(expression.template, expression.bindings)
@@ -1027,7 +1017,7 @@ extension Connection {
         try prepare(statement, bindings).prepareRowIterator()
     }
 
-    private func columnNamesForQuery(_ query: QueryType) throws -> [String: Int] {
+    func columnNamesForQuery(_ query: QueryType) throws -> [String: Int] {
         var (columnNames, idx) = ([String: Int](), 0)
         column: for each in query.clauses.select.columns {
             var names = each.expression.template.split { $0 == "." }.map(String.init)
@@ -1177,6 +1167,10 @@ public struct Row {
         self.values = values
     }
 
+	init(_ columnNames: [String: Int], _ values: [Binding?]) {
+		self.init(columnNames, CursorWithBindingArray(elements: values))
+	}
+
     func hasValue(for column: String) -> Bool {
         guard let idx = columnNames[column.quote()] else {
             return false

Tests/SQLiteTests/Extensions/FTSIntegrationTests.swift

@@ -54,6 +54,12 @@ class FTSIntegrationTests: SQLiteTestCase {
         XCTAssertEqual(matches.map { $0[email ]}, ["[email protected]"])
     }
 
+	func testAny() throws {
+		try createIndex()
+		let match = try db.prepare(index.match("Paul")).last
+		XCTAssertEqual(match?[email], "[email protected]")
+	}
+
     func testMatchPartial() throws {
         try insertUsers("Paula")
         try createIndex()
@@ -63,8 +69,8 @@ class FTSIntegrationTests: SQLiteTestCase {
 
     func testTrigramIndex() throws {
         try createTrigramIndex()
-        let matches = Array(try db.prepare(index.match("Paul")))
-        XCTAssertEqual(1, matches.count)
+        let matcheCount = try db.prepare(index.match("Paul")).count
+        XCTAssertEqual(1, matcheCount)
     }
 
     private func createOrSkip(_ createIndex: (Connection) throws -> Void) throws {

Tests/SQLiteTests/Typed/RowTests.swift

@@ -1,47 +1,6 @@
 import XCTest
 @testable import SQLite
 
-struct CursorWithStringArray: CursorProtocol {
-	let elements: [Binding?]
-	init(elements: [Binding?]) {
-		self.elements = elements
-	}
-
-	func getValue(_ idx: Int) throws -> Binding? {
-		elements[idx]
-	}
-	func getValue(_ idx: Int) throws -> Double {
-		guard let value = elements[idx] as? Double else {
-			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
-		}
-		return value
-	}
-	func getValue(_ idx: Int) throws -> Int64 {
-		guard let value = elements[idx] as? Int64 else {
-			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
-		}
-		return value
-	}
-	func getValue(_ idx: Int) throws -> String {
-		guard let value = elements[idx] as? String else {
-			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
-		}
-		return value
-	}
-	func getValue(_ idx: Int) throws -> Blob {
-		guard let value = elements[idx] as? Blob else {
-			throw QueryError.unexpectedNullValue(name: "column at index \(idx)")
-		}
-		return value
-	}
-}
-
-extension Row {
-	init(_ columnNames: [String: Int], _ values: [Binding?]) {
-		self.init(columnNames, CursorWithStringArray(elements: values))
-	}
-}
-
 class RowTests: XCTestCase {
     public func test_get_value() throws {
         let row = Row(["\"foo\"": 0], ["value"])