Merge pull request #73 from novi/fix-parameter-type

novi · web-flow · commit 667f56164e4a · 2018-02-27T17:59:52.000+09:00
Add support for table name, column type QueryParameter
diff --git a/Sources/MySQL/Blob.swift b/Sources/MySQL/Blob.swift
@@ -64,6 +64,9 @@ extension Data: QueryParameterType {
         buffer += "'"
         return buffer
     }
+    public func escapedForID() -> String? {
+        return nil
+    }
 }
 
 extension Data: QueryParameter {
diff --git a/Sources/MySQL/Connection.swift b/Sources/MySQL/Connection.swift
@@ -142,7 +142,7 @@ public final class Connection {
         return mysql_
     }
     
-    internal var ping: Bool {
+    internal func ping() -> Bool {
         _ = try? connectIfNeeded()
         guard let mysql = mysql else {
             return false
diff --git a/Sources/MySQL/ConnectionPool.swift b/Sources/MySQL/ConnectionPool.swift
@@ -57,7 +57,7 @@ final public class ConnectionPool: CustomStringConvertible {
     
     private func getUsableConnection() -> Connection? {
         for c in pool {
-            if c.isInUse == false && c.ping {
+            if c.isInUse == false && c.ping() {
                 c.isInUse = true
                 return c
             }
diff --git a/Sources/MySQL/Date.swift b/Sources/MySQL/Date.swift
@@ -111,7 +111,7 @@ extension Date: QueryParameter {
         } // TODO: in Linux
         
         // YYYY-MM-DD HH:MM:SS
-        return QueryParameterWrap( "'\(pad(num: comp.year ?? 0, digits: 4))-\(pad(num: comp.month ?? 0))-\(pad(num: comp.day ?? 0)) \(pad(num: comp.hour ?? 0)):\(pad(num: comp.minute ?? 0)):\(pad(num: comp.second ?? 0))'" )
+        return EscapedQueryParameter( "'\(pad(num: comp.year ?? 0, digits: 4))-\(pad(num: comp.month ?? 0))-\(pad(num: comp.day ?? 0)) \(pad(num: comp.hour ?? 0)):\(pad(num: comp.minute ?? 0)):\(pad(num: comp.second ?? 0))'" )
     }
 }
 
diff --git a/Sources/MySQL/EnumParameter.swift b/Sources/MySQL/EnumParameter.swift
@@ -22,9 +22,19 @@ extension SQLEnumType where RawValue == String {
     }
 }
 
+
 extension SQLEnumType where RawValue == String {
     public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {
         return rawValue.queryParameter(option: option)
     }
 }
 
+public protocol QueryEnumParameter: RawRepresentable, QueryParameter {
+    
+}
+
+extension QueryEnumParameter where Self.RawValue: QueryParameter {
+    public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {
+        return try rawValue.queryParameter(option: option)
+    }
+}
diff --git a/Sources/MySQL/ParameterBuilder.swift b/Sources/MySQL/ParameterBuilder.swift
@@ -6,19 +6,22 @@
 //  Copyright © 2015 Yusuke Ito. All rights reserved.
 //
 
+@available(*, deprecated)
 public func build<A: QueryParameter>(_ p: (A) ) -> [QueryParameter] {
     return [
         p
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter>(_ p: (A, B) ) -> [QueryParameter] {
     return [
         p.0,
         p.1
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter>(_ p: (A, B, C) ) -> [QueryParameter] {
     return [
         p.0,
@@ -27,6 +30,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter>(_ p:
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter>(_ p: (A, B, C, D) ) -> [QueryParameter] {
     return [
         p.0,
@@ -36,6 +40,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter>(_ p: (A, B, C, D, E) ) -> [QueryParameter] {
     return [
         p.0,
@@ -46,6 +51,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter, F: QueryParameter>(_ p: (A, B, C, D, E, F) ) -> [QueryParameter] {
     return [
         p.0,
@@ -57,6 +63,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu
     ]
 }
 
+@available(*, deprecated)
 public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter, F: QueryParameter, G: QueryParameter>(_ p: (A, B, C, D, E, F, G) ) -> [QueryParameter] {
     return [
         p.0,
@@ -67,4 +74,4 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu
         p.5,
         p.6
     ]
-}
+}
diff --git a/Sources/MySQL/QueryParameterType.swift b/Sources/MySQL/QueryParameterType.swift
@@ -43,7 +43,7 @@ public struct QueryParameterNull: QueryParameter, ExpressibleByNilLiteral {
         
     }
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( "NULL" )
+        return EscapedQueryParameter( "NULL" )
     }
 }
 
@@ -57,10 +57,10 @@ public struct QueryDictionary: QueryParameter {
         var keyVals: [String] = []
         for (k, v) in dict {
             if v == nil || v?.omitOnQueryParameter == false {
-                keyVals.append("\(SQLString.escapeId(string: k)) = \(try QueryParameterOptional(v).queryParameter(option: option).escaped())")
+                keyVals.append("\(SQLString.escapeForID(string: k)) = \(try QueryParameterOptional(v).queryParameter(option: option).escaped())")
             }
         }
-        return QueryParameterWrap( keyVals.joined(separator:  ", ") )
+        return EscapedQueryParameter( keyVals.joined(separator:  ", ") )
     }
 }
 
@@ -82,7 +82,7 @@ public struct QueryArray: QueryParameter, QueryArrayType {
         self.arr = arr.map { Optional($0) }
     }
     public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {
-        return QueryParameterWrap( try arr.filter({ val in
+        return EscapedQueryParameter( try arr.filter({ val in
             if let valid = val {
                 return valid.omitOnQueryParameter == false
             }
@@ -137,109 +137,117 @@ struct QueryParameterOptional: QueryParameter {
     }
 }
 
-struct QueryParameterWrap: QueryParameterType {
-    let val: String
-    init(_ val: String) {
-        self.val = val
+struct EscapedQueryParameter: QueryParameterType {
+    private let value: String
+    private let idParameter: String?
+    init(_ val: String, idParameter: String? = nil) {
+        self.value = val
+        self.idParameter = idParameter
     }
     func escaped() -> String {
-        return val
+        return value
+    }
+    func escapedForID() -> String? {
+        return idParameter
     }
 }
 
 extension String: QueryParameterType {
     public func escaped() -> String {
         return SQLString.escape(string: self)
     }
+    public func escapedForID() -> String? {
+        return SQLString.escapeForID(string: self)
+    }
 }
 
 extension String: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( SQLString.escape(string: self) )
+        return self
     }
 }
 
 extension Int: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension UInt: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Int64: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Int32: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Int16: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Int8: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension UInt64: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension UInt32: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension UInt16: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension UInt8: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Double: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Float: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(self) )
+        return EscapedQueryParameter( String(self) )
     }
 }
 
 extension Bool: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( self ? "true" : "false" )
+        return EscapedQueryParameter( self ? "true" : "false" )
     }
 }
 
 extension Decimal: QueryParameter {
     public func queryParameter(option: QueryParameterOption) -> QueryParameterType {
-        return QueryParameterWrap( String(describing: self) )
+        return EscapedQueryParameter( String(describing: self) )
     }
 }
 
diff --git a/Sources/MySQL/Result.swift b/Sources/MySQL/Result.swift
@@ -17,6 +17,7 @@ infix operator <| : DecodingPrecedence
 infix operator <|? : DecodingPrecedence
 
 
+@available(*, deprecated)
 public protocol QueryRowResultType {
     static func decodeRow(r: QueryRowResult) throws -> Self
 }
diff --git a/Sources/SQLFormatter/Error.swift b/Sources/SQLFormatter/Error.swift
@@ -9,5 +9,5 @@
 public enum QueryFormatError: Error {
     case castError(actual: String, expected: String, key: String)
     case queryParameterCountMismatch(query: String)
-    case queryParameterIdTypeError(query: String)
+    case queryParameterIDTypeError(given: String, query: String)
 }
diff --git a/Sources/SQLFormatter/QueryFormatter.swift b/Sources/SQLFormatter/QueryFormatter.swift
@@ -10,11 +10,12 @@ import Foundation
 
 public protocol QueryParameterType {
     func escaped() -> String
+    func escapedForID() -> String? // returns nil, if not supported for query id parameter
 }
 
 public struct SQLString {
     
-    public static func escapeId(string str: String) -> String {
+    public static func escapeForID(string str: String) -> String {
         var step1 = ""
         for c in str {
             switch c {
@@ -96,10 +97,10 @@ public struct QueryFormatter {
                 if placeHolderCount >= args.count {
                     throw QueryFormatError.queryParameterCountMismatch(query: query)
                 }
-                guard let val = args[placeHolderCount] as? String else {
-                    throw QueryFormatError.queryParameterIdTypeError(query: query)
+                guard let escapedVal = args[placeHolderCount].escapedForID() else {
+                    throw QueryFormatError.queryParameterIDTypeError(given: "\(args[placeHolderCount])", query: query)
                 }
-                formatted.replaceSubrange(r, with: SQLString.escapeId(string: val))
+                formatted.replaceSubrange(r, with: escapedVal)
                 scanRange = r.upperBound..<formatted.endIndex
             case "?":
                 if placeHolderCount >= args.count {
diff --git a/Tests/MySQLTests/ConnectionTests.swift b/Tests/MySQLTests/ConnectionTests.swift
@@ -32,13 +32,13 @@ final class ConnectionTests: XCTestCase, MySQLTestType {
     
     func testConnect() throws {
         let conn = try pool.getConnection()
-        XCTAssertTrue(conn.ping)
+        XCTAssertTrue(conn.ping())
     }
     
     func testConnect2() throws {
         let conn = try pool.getConnection()
         _ = try conn.query("SELECT 1;" as String)
-        XCTAssertTrue(conn.ping)
+        XCTAssertTrue(conn.ping())
     }
     
     struct Option: ConnectionOption {
diff --git a/Tests/MySQLTests/QueryFormatterTests.swift b/Tests/MySQLTests/QueryFormatterTests.swift
@@ -23,19 +23,24 @@ extension QueryFormatterTests {
 
 final class QueryFormatterTests: XCTestCase {
     
+    fileprivate enum TableName: String, QueryEnumParameter {
+        case user = "user"
+    }
+    
     func testBasicFormatting() throws {
         
-        let params: (String, String, Int, String, Int?) = (
+        let params: (String, TableName, String, Int, String, Int?) = (
             "i.d",
+            TableName.user,
             "id",
             1,
             "user's",
             nil
         )
         let args = build(params)
         
-        let formatted = try QueryFormatter.format(query: "SELECT name,??,id FROM users WHERE ?? = ? OR name = ? OR age is ?;", args: Connection.buildArgs(args, option: queryOption) )
-        XCTAssertEqual(formatted, "SELECT name,`i`.`d`,id FROM users WHERE `id` = 1 OR name = 'user\\'s' OR age is NULL;")
+        let formatted = try QueryFormatter.format(query: "SELECT name,??,id FROM ?? WHERE ?? = ? OR name = ? OR age is ?;", args: Connection.buildArgs(args, option: queryOption) )
+        XCTAssertEqual(formatted, "SELECT name,`i`.`d`,id FROM `user` WHERE `id` = 1 OR name = 'user\\'s' OR age is NULL;")
     }
     
     func testPlaceholder() throws {
diff --git a/Tests/MySQLTests/SQLTypeTests.swift b/Tests/MySQLTests/SQLTypeTests.swift
@@ -34,6 +34,11 @@ final class SQLTypeTests: XCTestCase {
         case second = "second' 2"
     }
     
+    enum SomeEnumParameter: String, QueryEnumParameter {
+        case first = "first 1"
+        case second = "second' 2"
+    }
+    
     enum SomeEnumCodable: String, Codable, QueryParameter {
         case first = "first 1"
         case second = "second' 2"

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,9 @@ extension Data: QueryParameterType {`
`64`	`64`	`buffer += "'"`
`65`	`65`	`return buffer`
`66`	`66`	`}`
	`67`	`+ public func escapedForID() -> String? {`
	`68`	`+ return nil`
	`69`	`+ }`
`67`	`70`	`}`
`68`	`71`
`69`	`72`	`extension Data: QueryParameter {`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ public final class Connection {`
`142`	`142`	`return mysql_`
`143`	`143`	`}`
`144`	`144`
`145`		`- internal var ping: Bool {`
	`145`	`+ internal func ping() -> Bool {`
`146`	`146`	`_ = try? connectIfNeeded()`
`147`	`147`	`guard let mysql = mysql else {`
`148`	`148`	`return false`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ final public class ConnectionPool: CustomStringConvertible {`
`57`	`57`
`58`	`58`	`private func getUsableConnection() -> Connection? {`
`59`	`59`	`for c in pool {`
`60`		`- if c.isInUse == false && c.ping {`
	`60`	`+ if c.isInUse == false && c.ping() {`
`61`	`61`	`c.isInUse = true`
`62`	`62`	`return c`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ extension Date: QueryParameter {`
`111`	`111`	`} // TODO: in Linux`
`112`	`112`
`113`	`113`	`// YYYY-MM-DD HH:MM:SS`
`114`		`- return QueryParameterWrap( "'\(pad(num: comp.year ?? 0, digits: 4))-\(pad(num: comp.month ?? 0))-\(pad(num: comp.day ?? 0)) \(pad(num: comp.hour ?? 0)):\(pad(num: comp.minute ?? 0)):\(pad(num: comp.second ?? 0))'" )`
	`114`	`+ return EscapedQueryParameter( "'\(pad(num: comp.year ?? 0, digits: 4))-\(pad(num: comp.month ?? 0))-\(pad(num: comp.day ?? 0)) \(pad(num: comp.hour ?? 0)):\(pad(num: comp.minute ?? 0)):\(pad(num: comp.second ?? 0))'" )`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,19 @@ extension SQLEnumType where RawValue == String {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
	`25`	`+`
`25`	`26`	`extension SQLEnumType where RawValue == String {`
`26`	`27`	`public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {`
`27`	`28`	`return rawValue.queryParameter(option: option)`
`28`	`29`	`}`
`29`	`30`	`}`
`30`	`31`
	`32`	`+public protocol QueryEnumParameter: RawRepresentable, QueryParameter {`
	`33`	`+`
	`34`	`+}`
	`35`	`+`
	`36`	`+extension QueryEnumParameter where Self.RawValue: QueryParameter {`
	`37`	`+ public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {`
	`38`	`+ return try rawValue.queryParameter(option: option)`
	`39`	`+ }`
	`40`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -6,19 +6,22 @@`
`6`	`6`	`// Copyright © 2015 Yusuke Ito. All rights reserved.`
`7`	`7`	`//`
`8`	`8`
	`9`	`+@available(*, deprecated)`
`9`	`10`	`public func build<A: QueryParameter>(_ p: (A) ) -> [QueryParameter] {`
`10`	`11`	`return [`
`11`	`12`	`p`
`12`	`13`	`]`
`13`	`14`	`}`
`14`	`15`
	`16`	`+@available(*, deprecated)`
`15`	`17`	`public func build<A: QueryParameter, B: QueryParameter>(_ p: (A, B) ) -> [QueryParameter] {`
`16`	`18`	`return [`
`17`	`19`	`p.0,`
`18`	`20`	`p.1`
`19`	`21`	`]`
`20`	`22`	`}`
`21`	`23`
	`24`	`+@available(*, deprecated)`
`22`	`25`	`public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter>(_ p: (A, B, C) ) -> [QueryParameter] {`
`23`	`26`	`return [`
`24`	`27`	`p.0,`
`@@ -27,6 +30,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter>(_ p:`
`27`	`30`	`]`
`28`	`31`	`}`
`29`	`32`
	`33`	`+@available(*, deprecated)`
`30`	`34`	`public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter>(_ p: (A, B, C, D) ) -> [QueryParameter] {`
`31`	`35`	`return [`
`32`	`36`	`p.0,`
`@@ -36,6 +40,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu`
`36`	`40`	`]`
`37`	`41`	`}`
`38`	`42`
	`43`	`+@available(*, deprecated)`
`39`	`44`	`public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter>(_ p: (A, B, C, D, E) ) -> [QueryParameter] {`
`40`	`45`	`return [`
`41`	`46`	`p.0,`
`@@ -46,6 +51,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu`
`46`	`51`	`]`
`47`	`52`	`}`
`48`	`53`
	`54`	`+@available(*, deprecated)`
`49`	`55`	`public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter, F: QueryParameter>(_ p: (A, B, C, D, E, F) ) -> [QueryParameter] {`
`50`	`56`	`return [`
`51`	`57`	`p.0,`
`@@ -57,6 +63,7 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu`
`57`	`63`	`]`
`58`	`64`	`}`
`59`	`65`
	`66`	`+@available(*, deprecated)`
`60`	`67`	`public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: QueryParameter, E: QueryParameter, F: QueryParameter, G: QueryParameter>(_ p: (A, B, C, D, E, F, G) ) -> [QueryParameter] {`
`61`	`68`	`return [`
`62`	`69`	`p.0,`
`@@ -67,4 +74,4 @@ public func build<A: QueryParameter, B: QueryParameter, C: QueryParameter, D: Qu`
`67`	`74`	`p.5,`
`68`	`75`	`p.6`
`69`	`76`	`]`
`70`		`-}`
	`77`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public struct QueryParameterNull: QueryParameter, ExpressibleByNilLiteral {`
`43`	`43`
`44`	`44`	`}`
`45`	`45`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`46`		`- return QueryParameterWrap( "NULL" )`
	`46`	`+ return EscapedQueryParameter( "NULL" )`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`@@ -57,10 +57,10 @@ public struct QueryDictionary: QueryParameter {`
`57`	`57`	`var keyVals: [String] = []`
`58`	`58`	`for (k, v) in dict {`
`59`	`59`	`if v == nil \|\| v?.omitOnQueryParameter == false {`
`60`		`- keyVals.append("\(SQLString.escapeId(string: k)) = \(try QueryParameterOptional(v).queryParameter(option: option).escaped())")`
	`60`	`+ keyVals.append("\(SQLString.escapeForID(string: k)) = \(try QueryParameterOptional(v).queryParameter(option: option).escaped())")`
`61`	`61`	`}`
`62`	`62`	`}`
`63`		`- return QueryParameterWrap( keyVals.joined(separator: ", ") )`
	`63`	`+ return EscapedQueryParameter( keyVals.joined(separator: ", ") )`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`
`@@ -82,7 +82,7 @@ public struct QueryArray: QueryParameter, QueryArrayType {`
`82`	`82`	`self.arr = arr.map { Optional($0) }`
`83`	`83`	`}`
`84`	`84`	`public func queryParameter(option: QueryParameterOption) throws -> QueryParameterType {`
`85`		`- return QueryParameterWrap( try arr.filter({ val in`
	`85`	`+ return EscapedQueryParameter( try arr.filter({ val in`
`86`	`86`	`if let valid = val {`
`87`	`87`	`return valid.omitOnQueryParameter == false`
`88`	`88`	`}`
`@@ -137,109 +137,117 @@ struct QueryParameterOptional: QueryParameter {`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`
`140`		`-struct QueryParameterWrap: QueryParameterType {`
`141`		`- let val: String`
`142`		`- init(_ val: String) {`
`143`		`- self.val = val`
	`140`	`+struct EscapedQueryParameter: QueryParameterType {`
	`141`	`+ private let value: String`
	`142`	`+ private let idParameter: String?`
	`143`	`+ init(_ val: String, idParameter: String? = nil) {`
	`144`	`+ self.value = val`
	`145`	`+ self.idParameter = idParameter`
`144`	`146`	`}`
`145`	`147`	`func escaped() -> String {`
`146`		`- return val`
	`148`	`+ return value`
	`149`	`+ }`
	`150`	`+ func escapedForID() -> String? {`
	`151`	`+ return idParameter`
`147`	`152`	`}`
`148`	`153`	`}`
`149`	`154`
`150`	`155`	`extension String: QueryParameterType {`
`151`	`156`	`public func escaped() -> String {`
`152`	`157`	`return SQLString.escape(string: self)`
`153`	`158`	`}`
	`159`	`+ public func escapedForID() -> String? {`
	`160`	`+ return SQLString.escapeForID(string: self)`
	`161`	`+ }`
`154`	`162`	`}`
`155`	`163`
`156`	`164`	`extension String: QueryParameter {`
`157`	`165`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`158`		`- return QueryParameterWrap( SQLString.escape(string: self) )`
	`166`	`+ return self`
`159`	`167`	`}`
`160`	`168`	`}`
`161`	`169`
`162`	`170`	`extension Int: QueryParameter {`
`163`	`171`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`164`		`- return QueryParameterWrap( String(self) )`
	`172`	`+ return EscapedQueryParameter( String(self) )`
`165`	`173`	`}`
`166`	`174`	`}`
`167`	`175`
`168`	`176`	`extension UInt: QueryParameter {`
`169`	`177`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`170`		`- return QueryParameterWrap( String(self) )`
	`178`	`+ return EscapedQueryParameter( String(self) )`
`171`	`179`	`}`
`172`	`180`	`}`
`173`	`181`
`174`	`182`	`extension Int64: QueryParameter {`
`175`	`183`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`176`		`- return QueryParameterWrap( String(self) )`
	`184`	`+ return EscapedQueryParameter( String(self) )`
`177`	`185`	`}`
`178`	`186`	`}`
`179`	`187`
`180`	`188`	`extension Int32: QueryParameter {`
`181`	`189`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`182`		`- return QueryParameterWrap( String(self) )`
	`190`	`+ return EscapedQueryParameter( String(self) )`
`183`	`191`	`}`
`184`	`192`	`}`
`185`	`193`
`186`	`194`	`extension Int16: QueryParameter {`
`187`	`195`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`188`		`- return QueryParameterWrap( String(self) )`
	`196`	`+ return EscapedQueryParameter( String(self) )`
`189`	`197`	`}`
`190`	`198`	`}`
`191`	`199`
`192`	`200`	`extension Int8: QueryParameter {`
`193`	`201`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`194`		`- return QueryParameterWrap( String(self) )`
	`202`	`+ return EscapedQueryParameter( String(self) )`
`195`	`203`	`}`
`196`	`204`	`}`
`197`	`205`
`198`	`206`	`extension UInt64: QueryParameter {`
`199`	`207`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`200`		`- return QueryParameterWrap( String(self) )`
	`208`	`+ return EscapedQueryParameter( String(self) )`
`201`	`209`	`}`
`202`	`210`	`}`
`203`	`211`
`204`	`212`	`extension UInt32: QueryParameter {`
`205`	`213`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`206`		`- return QueryParameterWrap( String(self) )`
	`214`	`+ return EscapedQueryParameter( String(self) )`
`207`	`215`	`}`
`208`	`216`	`}`
`209`	`217`
`210`	`218`	`extension UInt16: QueryParameter {`
`211`	`219`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`212`		`- return QueryParameterWrap( String(self) )`
	`220`	`+ return EscapedQueryParameter( String(self) )`
`213`	`221`	`}`
`214`	`222`	`}`
`215`	`223`
`216`	`224`	`extension UInt8: QueryParameter {`
`217`	`225`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`218`		`- return QueryParameterWrap( String(self) )`
	`226`	`+ return EscapedQueryParameter( String(self) )`
`219`	`227`	`}`
`220`	`228`	`}`
`221`	`229`
`222`	`230`	`extension Double: QueryParameter {`
`223`	`231`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`224`		`- return QueryParameterWrap( String(self) )`
	`232`	`+ return EscapedQueryParameter( String(self) )`
`225`	`233`	`}`
`226`	`234`	`}`
`227`	`235`
`228`	`236`	`extension Float: QueryParameter {`
`229`	`237`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`230`		`- return QueryParameterWrap( String(self) )`
	`238`	`+ return EscapedQueryParameter( String(self) )`
`231`	`239`	`}`
`232`	`240`	`}`
`233`	`241`
`234`	`242`	`extension Bool: QueryParameter {`
`235`	`243`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`236`		`- return QueryParameterWrap( self ? "true" : "false" )`
	`244`	`+ return EscapedQueryParameter( self ? "true" : "false" )`
`237`	`245`	`}`
`238`	`246`	`}`
`239`	`247`
`240`	`248`	`extension Decimal: QueryParameter {`
`241`	`249`	`public func queryParameter(option: QueryParameterOption) -> QueryParameterType {`
`242`		`- return QueryParameterWrap( String(describing: self) )`
	`250`	`+ return EscapedQueryParameter( String(describing: self) )`
`243`	`251`	`}`
`244`	`252`	`}`
`245`	`253`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ infix operator <\| : DecodingPrecedence`
`17`	`17`	`infix operator <\|? : DecodingPrecedence`
`18`	`18`
`19`	`19`
	`20`	`+@available(*, deprecated)`
`20`	`21`	`public protocol QueryRowResultType {`
`21`	`22`	`static func decodeRow(r: QueryRowResult) throws -> Self`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@`
`9`	`9`	`public enum QueryFormatError: Error {`
`10`	`10`	`case castError(actual: String, expected: String, key: String)`
`11`	`11`	`case queryParameterCountMismatch(query: String)`
`12`		`- case queryParameterIdTypeError(query: String)`
	`12`	`+ case queryParameterIDTypeError(given: String, query: String)`
`13`	`13`	`}`