Merge pull request #398 from JavaNut13/master

hiltonc · web-flow · commit 8cc5a6e7653f · 2016-07-20T19:02:28.000-06:00
Scalar functions should throw errors
diff --git a/SQLite/Core/Connection.swift b/SQLite/Core/Connection.swift
@@ -236,8 +236,8 @@ public final class Connection {
     ///   - bindings: A list of parameters to bind to the statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(statement: String, _ bindings: Binding?...) -> Binding? {
-        return scalar(statement, bindings)
+    @warn_unused_result public func scalar(statement: String, _ bindings: Binding?...) throws -> Binding? {
+        return try scalar(statement, bindings)
     }
 
     /// Runs a single SQL statement (with optional parameter bindings),
@@ -250,8 +250,8 @@ public final class Connection {
     ///   - bindings: A list of parameters to bind to the statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(statement: String, _ bindings: [Binding?]) -> Binding? {
-        return try! prepare(statement).scalar(bindings)
+    @warn_unused_result public func scalar(statement: String, _ bindings: [Binding?]) throws -> Binding? {
+        return try prepare(statement).scalar(bindings)
     }
 
     /// Runs a single SQL statement (with optional parameter bindings),
@@ -264,8 +264,8 @@ public final class Connection {
     ///   - bindings: A dictionary of named parameters to bind to the statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(statement: String, _ bindings: [String: Binding?]) -> Binding? {
-        return try! prepare(statement).scalar(bindings)
+    @warn_unused_result public func scalar(statement: String, _ bindings: [String: Binding?]) throws -> Binding? {
+        return try prepare(statement).scalar(bindings)
     }
 
     // MARK: - Transactions
@@ -556,11 +556,11 @@ public final class Connection {
     ///
     ///   - block: A collation function that takes two strings and returns the
     ///     comparison result.
-    public func createCollation(collation: String, _ block: (lhs: String, rhs: String) -> ComparisonResult) {
+    public func createCollation(collation: String, _ block: (lhs: String, rhs: String) -> ComparisonResult) throws {
         let box: Collation = { lhs, rhs in
             Int32(block(lhs: String.fromCString(UnsafePointer<Int8>(lhs))!, rhs: String.fromCString(UnsafePointer<Int8>(rhs))!).rawValue)
         }
-        try! check(sqlite3_create_collation_v2(handle, collation, SQLITE_UTF8, unsafeBitCast(box, UnsafeMutablePointer<Void>.self), { callback, _, lhs, _, rhs in
+        try check(sqlite3_create_collation_v2(handle, collation, SQLITE_UTF8, unsafeBitCast(box, UnsafeMutablePointer<Void>.self), { callback, _, lhs, _, rhs in
             unsafeBitCast(callback, Collation.self)(lhs, rhs)
         }, nil))
         collations[collation] = box
diff --git a/SQLite/Core/Statement.swift b/SQLite/Core/Statement.swift
@@ -152,30 +152,30 @@ public final class Statement {
     /// - Parameter bindings: A list of parameters to bind to the statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(bindings: Binding?...) -> Binding? {
+    @warn_unused_result public func scalar(bindings: Binding?...) throws -> Binding? {
         guard bindings.isEmpty else {
-            return scalar(bindings)
+            return try scalar(bindings)
         }
 
         reset(clearBindings: false)
-        try! step()
+        try step()
         return row[0]
     }
 
     /// - Parameter bindings: A list of parameters to bind to the statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(bindings: [Binding?]) -> Binding? {
-        return bind(bindings).scalar()
+    @warn_unused_result public func scalar(bindings: [Binding?]) throws -> Binding? {
+        return try bind(bindings).scalar()
     }
 
 
     /// - Parameter bindings: A dictionary of named parameters to bind to the
     ///   statement.
     ///
     /// - Returns: The first value of the first row returned.
-    @warn_unused_result public func scalar(bindings: [String: Binding?]) -> Binding? {
-        return bind(bindings).scalar()
+    @warn_unused_result public func scalar(bindings: [String: Binding?]) throws -> Binding? {
+        return try bind(bindings).scalar()
     }
 
     public func step() throws -> Bool {
diff --git a/SQLite/Typed/Query.swift b/SQLite/Typed/Query.swift
@@ -932,30 +932,30 @@ extension Connection {
         }
     }
 
-    public func scalar<V : Value>(query: ScalarQuery<V>) -> V {
+    public func scalar<V : Value>(query: ScalarQuery<V>) throws -> V {
         let expression = query.expression
-        return value(scalar(expression.template, expression.bindings))
+        return value(try scalar(expression.template, expression.bindings))
     }
 
-    public func scalar<V : Value>(query: ScalarQuery<V?>) -> V.ValueType? {
+    public func scalar<V : Value>(query: ScalarQuery<V?>) throws -> V.ValueType? {
         let expression = query.expression
-        guard let value = scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }
+        guard let value = try scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }
         return V.fromDatatypeValue(value)
     }
 
-    public func scalar<V : Value>(query: Select<V>) -> V {
+    public func scalar<V : Value>(query: Select<V>) throws -> V {
         let expression = query.expression
-        return value(scalar(expression.template, expression.bindings))
+        return value(try scalar(expression.template, expression.bindings))
     }
 
-    public func scalar<V : Value>(query: Select<V?>) ->  V.ValueType? {
+    public func scalar<V : Value>(query: Select<V?>) throws ->  V.ValueType? {
         let expression = query.expression
-        guard let value = scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }
+        guard let value = try scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }
         return V.fromDatatypeValue(value)
     }
 
-    public func pluck(query: QueryType) -> Row? {
-        return try! prepare(query.limit(1, query.clauses.limit?.offset)).generate().next()
+    public func pluck(query: QueryType) throws -> Row? {
+        return try prepare(query.limit(1, query.clauses.limit?.offset)).generate().next()
     }
 
     /// Runs an `Insert` query.
diff --git a/SQLiteTests/ConnectionTests.swift b/SQLiteTests/ConnectionTests.swift
@@ -87,10 +87,10 @@ class ConnectionTests : SQLiteTestCase {
     }
 
     func test_scalar_preparesRunsAndReturnsScalarValues() {
-        XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = 0") as? Int64)
-        XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = ?", 0) as? Int64)
-        XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = ?", [0]) as? Int64)
-        XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = $admin", ["$admin": 0]) as? Int64)
+        XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = 0") as? Int64)
+        XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = ?", 0) as? Int64)
+        XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = ?", [0]) as? Int64)
+        XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = $admin", ["$admin": 0]) as? Int64)
         AssertSQL("SELECT count(*) FROM users WHERE admin = 0", 4)
     }
 
@@ -238,7 +238,7 @@ class ConnectionTests : SQLiteTestCase {
             try! db.transaction {
                 try self.InsertUser("alice")
             }
-            XCTAssertEqual(1, db.scalar("SELECT count(*) FROM users") as? Int64)
+            XCTAssertEqual(1, try! db.scalar("SELECT count(*) FROM users") as? Int64)
         }
     }
 
@@ -252,7 +252,7 @@ class ConnectionTests : SQLiteTestCase {
                 }
             } catch {
             }
-            XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users") as? Int64)
+            XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users") as? Int64)
         }
     }
 
@@ -268,36 +268,36 @@ class ConnectionTests : SQLiteTestCase {
                 }
             } catch {
             }
-            XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users") as? Int64)
+            XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users") as? Int64)
         }
     }
 
     func test_createFunction_withArrayArguments() {
         db.createFunction("hello") { $0[0].map { "Hello, \($0)!" } }
 
-        XCTAssertEqual("Hello, world!", db.scalar("SELECT hello('world')") as? String)
-        XCTAssert(db.scalar("SELECT hello(NULL)") == nil)
+        XCTAssertEqual("Hello, world!", try! db.scalar("SELECT hello('world')") as? String)
+        XCTAssert(try! db.scalar("SELECT hello(NULL)") == nil)
     }
 
     func test_createFunction_createsQuotableFunction() {
         db.createFunction("hello world") { $0[0].map { "Hello, \($0)!" } }
 
-        XCTAssertEqual("Hello, world!", db.scalar("SELECT \"hello world\"('world')") as? String)
-        XCTAssert(db.scalar("SELECT \"hello world\"(NULL)") == nil)
+        XCTAssertEqual("Hello, world!", try! db.scalar("SELECT \"hello world\"('world')") as? String)
+        XCTAssert(try! db.scalar("SELECT \"hello world\"(NULL)") == nil)
     }
 
     func test_createCollation_createsCollation() {
-        db.createCollation("NODIACRITIC") { lhs, rhs in
+        try! db.createCollation("NODIACRITIC") { lhs, rhs in
             return lhs.compare(rhs, options: .DiacriticInsensitiveSearch)
         }
-        XCTAssertEqual(1, db.scalar("SELECT ? = ? COLLATE NODIACRITIC", "cafe", "café") as? Int64)
+        XCTAssertEqual(1, try! db.scalar("SELECT ? = ? COLLATE NODIACRITIC", "cafe", "café") as? Int64)
     }
 
     func test_createCollation_createsQuotableCollation() {
-        db.createCollation("NO DIACRITIC") { lhs, rhs in
+        try! db.createCollation("NO DIACRITIC") { lhs, rhs in
             return lhs.compare(rhs, options: .DiacriticInsensitiveSearch)
         }
-        XCTAssertEqual(1, db.scalar("SELECT ? = ? COLLATE \"NO DIACRITIC\"", "cafe", "café") as? Int64)
+        XCTAssertEqual(1, try! db.scalar("SELECT ? = ? COLLATE \"NO DIACRITIC\"", "cafe", "café") as? Int64)
     }
 
     func test_interrupt_interruptsLongRunningQuery() {
diff --git a/SQLiteTests/FTS4Tests.swift b/SQLiteTests/FTS4Tests.swift
@@ -202,7 +202,7 @@ class FTS4IntegrationTests : SQLiteTestCase {
         AssertSQL("CREATE VIRTUAL TABLE \"emails\" USING fts4(\"subject\", \"body\", tokenize=\"SQLite.swift\" \"tokenizer\")")
 
         try! db.run(emails.insert(subject <- "Aún más cáfe!"))
-        XCTAssertEqual(1, db.scalar(emails.filter(emails.match("aun")).count))
+        XCTAssertEqual(1, try! db.scalar(emails.filter(emails.match("aun")).count))
     }
 #endif
 }
diff --git a/SQLiteTests/QueryTests.swift b/SQLiteTests/QueryTests.swift
@@ -306,16 +306,16 @@ class QueryIntegrationTests : SQLiteTestCase {
     }
 
     func test_scalar() {
-        XCTAssertEqual(0, db.scalar(users.count))
-        XCTAssertEqual(false, db.scalar(users.exists))
+        XCTAssertEqual(0, try! db.scalar(users.count))
+        XCTAssertEqual(false, try! db.scalar(users.exists))
 
         try! InsertUsers("alice")
-        XCTAssertEqual(1, db.scalar(users.select(id.average)))
+        XCTAssertEqual(1, try! db.scalar(users.select(id.average)))
     }
 
     func test_pluck() {
         let rowid = try! db.run(users.insert(email <- "alice@example.com"))
-        XCTAssertEqual(rowid, db.pluck(users)![id])
+        XCTAssertEqual(rowid, try! db.pluck(users)![id])
     }
 
     func test_insert() {

Original file line number	Diff line number	Diff line change
`@@ -932,30 +932,30 @@ extension Connection {`
`932`	`932`	`}`
`933`	`933`	`}`
`934`	`934`
`935`		`- public func scalar<V : Value>(query: ScalarQuery<V>) -> V {`
	`935`	`+ public func scalar<V : Value>(query: ScalarQuery<V>) throws -> V {`
`936`	`936`	`let expression = query.expression`
`937`		`- return value(scalar(expression.template, expression.bindings))`
	`937`	`+ return value(try scalar(expression.template, expression.bindings))`
`938`	`938`	`}`
`939`	`939`
`940`		`- public func scalar<V : Value>(query: ScalarQuery<V?>) -> V.ValueType? {`
	`940`	`+ public func scalar<V : Value>(query: ScalarQuery<V?>) throws -> V.ValueType? {`
`941`	`941`	`let expression = query.expression`
`942`		`- guard let value = scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }`
	`942`	`+ guard let value = try scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }`
`943`	`943`	`return V.fromDatatypeValue(value)`
`944`	`944`	`}`
`945`	`945`
`946`		`- public func scalar<V : Value>(query: Select<V>) -> V {`
	`946`	`+ public func scalar<V : Value>(query: Select<V>) throws -> V {`
`947`	`947`	`let expression = query.expression`
`948`		`- return value(scalar(expression.template, expression.bindings))`
	`948`	`+ return value(try scalar(expression.template, expression.bindings))`
`949`	`949`	`}`
`950`	`950`
`951`		`- public func scalar<V : Value>(query: Select<V?>) -> V.ValueType? {`
	`951`	`+ public func scalar<V : Value>(query: Select<V?>) throws -> V.ValueType? {`
`952`	`952`	`let expression = query.expression`
`953`		`- guard let value = scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }`
	`953`	`+ guard let value = try scalar(expression.template, expression.bindings) as? V.Datatype else { return nil }`
`954`	`954`	`return V.fromDatatypeValue(value)`
`955`	`955`	`}`
`956`	`956`
`957`		`- public func pluck(query: QueryType) -> Row? {`
`958`		`- return try! prepare(query.limit(1, query.clauses.limit?.offset)).generate().next()`
	`957`	`+ public func pluck(query: QueryType) throws -> Row? {`
	`958`	`+ return try prepare(query.limit(1, query.clauses.limit?.offset)).generate().next()`
`959`	`959`	`}`
`960`	`960`
`961`	`961`	/// Runs an `Insert` query.
Original file line number	Diff line number	Diff line change
`@@ -87,10 +87,10 @@ class ConnectionTests : SQLiteTestCase {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`func test_scalar_preparesRunsAndReturnsScalarValues() {`
`90`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = 0") as? Int64)`
`91`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = ?", 0) as? Int64)`
`92`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = ?", [0]) as? Int64)`
`93`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users WHERE admin = $admin", ["$admin": 0]) as? Int64)`
	`90`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = 0") as? Int64)`
	`91`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = ?", 0) as? Int64)`
	`92`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = ?", [0]) as? Int64)`
	`93`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users WHERE admin = $admin", ["$admin": 0]) as? Int64)`
`94`	`94`	`AssertSQL("SELECT count(*) FROM users WHERE admin = 0", 4)`
`95`	`95`	`}`
`96`	`96`
`@@ -238,7 +238,7 @@ class ConnectionTests : SQLiteTestCase {`
`238`	`238`	`try! db.transaction {`
`239`	`239`	`try self.InsertUser("alice")`
`240`	`240`	`}`
`241`		`- XCTAssertEqual(1, db.scalar("SELECT count(*) FROM users") as? Int64)`
	`241`	`+ XCTAssertEqual(1, try! db.scalar("SELECT count(*) FROM users") as? Int64)`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`
`@@ -252,7 +252,7 @@ class ConnectionTests : SQLiteTestCase {`
`252`	`252`	`}`
`253`	`253`	`} catch {`
`254`	`254`	`}`
`255`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users") as? Int64)`
	`255`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users") as? Int64)`
`256`	`256`	`}`
`257`	`257`	`}`
`258`	`258`
`@@ -268,36 +268,36 @@ class ConnectionTests : SQLiteTestCase {`
`268`	`268`	`}`
`269`	`269`	`} catch {`
`270`	`270`	`}`
`271`		`- XCTAssertEqual(0, db.scalar("SELECT count(*) FROM users") as? Int64)`
	`271`	`+ XCTAssertEqual(0, try! db.scalar("SELECT count(*) FROM users") as? Int64)`
`272`	`272`	`}`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`func test_createFunction_withArrayArguments() {`
`276`	`276`	`db.createFunction("hello") { $0[0].map { "Hello, \($0)!" } }`
`277`	`277`
`278`		`- XCTAssertEqual("Hello, world!", db.scalar("SELECT hello('world')") as? String)`
`279`		`- XCTAssert(db.scalar("SELECT hello(NULL)") == nil)`
	`278`	`+ XCTAssertEqual("Hello, world!", try! db.scalar("SELECT hello('world')") as? String)`
	`279`	`+ XCTAssert(try! db.scalar("SELECT hello(NULL)") == nil)`
`280`	`280`	`}`
`281`	`281`
`282`	`282`	`func test_createFunction_createsQuotableFunction() {`
`283`	`283`	`db.createFunction("hello world") { $0[0].map { "Hello, \($0)!" } }`
`284`	`284`
`285`		`- XCTAssertEqual("Hello, world!", db.scalar("SELECT \"hello world\"('world')") as? String)`
`286`		`- XCTAssert(db.scalar("SELECT \"hello world\"(NULL)") == nil)`
	`285`	`+ XCTAssertEqual("Hello, world!", try! db.scalar("SELECT \"hello world\"('world')") as? String)`
	`286`	`+ XCTAssert(try! db.scalar("SELECT \"hello world\"(NULL)") == nil)`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`func test_createCollation_createsCollation() {`
`290`		`- db.createCollation("NODIACRITIC") { lhs, rhs in`
	`290`	`+ try! db.createCollation("NODIACRITIC") { lhs, rhs in`
`291`	`291`	`return lhs.compare(rhs, options: .DiacriticInsensitiveSearch)`
`292`	`292`	`}`
`293`		`- XCTAssertEqual(1, db.scalar("SELECT ? = ? COLLATE NODIACRITIC", "cafe", "café") as? Int64)`
	`293`	`+ XCTAssertEqual(1, try! db.scalar("SELECT ? = ? COLLATE NODIACRITIC", "cafe", "café") as? Int64)`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`func test_createCollation_createsQuotableCollation() {`
`297`		`- db.createCollation("NO DIACRITIC") { lhs, rhs in`
	`297`	`+ try! db.createCollation("NO DIACRITIC") { lhs, rhs in`
`298`	`298`	`return lhs.compare(rhs, options: .DiacriticInsensitiveSearch)`
`299`	`299`	`}`
`300`		`- XCTAssertEqual(1, db.scalar("SELECT ? = ? COLLATE \"NO DIACRITIC\"", "cafe", "café") as? Int64)`
	`300`	`+ XCTAssertEqual(1, try! db.scalar("SELECT ? = ? COLLATE \"NO DIACRITIC\"", "cafe", "café") as? Int64)`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`func test_interrupt_interruptsLongRunningQuery() {`
Original file line number	Diff line number	Diff line change
`@@ -202,7 +202,7 @@ class FTS4IntegrationTests : SQLiteTestCase {`
`202`	`202`	`AssertSQL("CREATE VIRTUAL TABLE \"emails\" USING fts4(\"subject\", \"body\", tokenize=\"SQLite.swift\" \"tokenizer\")")`
`203`	`203`
`204`	`204`	`try! db.run(emails.insert(subject <- "Aún más cáfe!"))`
`205`		`- XCTAssertEqual(1, db.scalar(emails.filter(emails.match("aun")).count))`
	`205`	`+ XCTAssertEqual(1, try! db.scalar(emails.filter(emails.match("aun")).count))`
`206`	`206`	`}`
`207`	`207`	`#endif`
`208`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -306,16 +306,16 @@ class QueryIntegrationTests : SQLiteTestCase {`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`func test_scalar() {`
`309`		`- XCTAssertEqual(0, db.scalar(users.count))`
`310`		`- XCTAssertEqual(false, db.scalar(users.exists))`
	`309`	`+ XCTAssertEqual(0, try! db.scalar(users.count))`
	`310`	`+ XCTAssertEqual(false, try! db.scalar(users.exists))`
`311`	`311`
`312`	`312`	`try! InsertUsers("alice")`
`313`		`- XCTAssertEqual(1, db.scalar(users.select(id.average)))`
	`313`	`+ XCTAssertEqual(1, try! db.scalar(users.select(id.average)))`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`func test_pluck() {`
`317`	`317`	`let rowid = try! db.run(users.insert(email <- "[email protected]"))`
`318`		`- XCTAssertEqual(rowid, db.pluck(users)![id])`
	`318`	`+ XCTAssertEqual(rowid, try! db.pluck(users)![id])`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`func test_insert() {`