Add PostgresQuery (vapor#223)

Author: fabianfett

Sources/PostgresNIO/Connection/PostgresConnection+Connect.swift

@@ -10,16 +10,11 @@ extension PostgresConnection {
         logger: Logger = .init(label: "codes.vapor.postgres"),
         on eventLoop: EventLoop
     ) -> EventLoopFuture<PostgresConnection> {
-        
-        let coders = PSQLConnection.Configuration.Coders(
-            jsonEncoder: _defaultJSONEncoder
-        )
-        
         let configuration = PSQLConnection.Configuration(
             connection: .resolved(address: socketAddress, serverName: serverHostname),
             authentication: nil,
-            tlsConfiguration: tlsConfiguration,
-            coders: coders)
+            tlsConfiguration: tlsConfiguration
+        )
 
         return PSQLConnection.connect(
             configuration: configuration,

Sources/PostgresNIO/Connection/PostgresConnection+Database.swift

@@ -15,7 +15,14 @@ extension PostgresConnection: PostgresDatabase {
 
         switch command {
         case .query(let query, let binds, let onMetadata, let onRow):
-            resultFuture = self.underlying.query(query, binds, logger: logger).flatMap { stream in
+            var psqlQuery = PostgresQuery(unsafeSQL: query, binds: .init(capacity: binds.count))
+            binds.forEach {
+                // We can bang the try here as encoding PostgresData does not throw. The throw
+                // is just an option for the protocol.
+                try! psqlQuery.appendBinding($0, context: .default)
+            }
+
+            resultFuture = self.underlying.query(psqlQuery, logger: logger).flatMap { stream in
                 let fields = stream.rowDescription.map { column in
                     PostgresMessage.RowDescription.Field(
                         name: column.name,
@@ -34,7 +41,14 @@ extension PostgresConnection: PostgresDatabase {
                 }
             }
         case .queryAll(let query, let binds, let onResult):
-            resultFuture = self.underlying.query(query, binds, logger: logger).flatMap { rows in
+            var psqlQuery = PostgresQuery(unsafeSQL: query, binds: .init(capacity: binds.count))
+            binds.forEach {
+                // We can bang the try here as encoding PostgresData does not throw. The throw
+                // is just an option for the protocol.
+                try! psqlQuery.appendBinding($0, context: .default)
+            }
+
+            resultFuture = self.underlying.query(psqlQuery, logger: logger).flatMap { rows in
                 let fields = rows.rowDescription.map { column in
                     PostgresMessage.RowDescription.Field(
                         name: column.name,
@@ -65,7 +79,18 @@ extension PostgresConnection: PostgresDatabase {
                 request.prepared = PreparedQuery(underlying: $0, database: self)
             }
         case .executePreparedStatement(let preparedQuery, let binds, let onRow):
-            resultFuture = self.underlying.execute(preparedQuery.underlying, binds, logger: logger).flatMap { rows in
+            var bindings = PostgresBindings()
+            binds.forEach { data in
+                try! bindings.append(data, context: .default)
+            }
+
+            let statement = PSQLExecuteStatement(
+                name: preparedQuery.underlying.name,
+                binds: bindings,
+                rowDescription: preparedQuery.underlying.rowDescription
+            )
+
+            resultFuture = self.underlying.execute(statement, logger: logger).flatMap { rows in
                 guard let lookupTable = preparedQuery.lookupTable else {
                     return self.eventLoop.makeSucceededFuture(())
                 }

Sources/PostgresNIO/Data/PostgresDataType.swift

@@ -26,7 +26,7 @@ public typealias PostgresFormatCode = PostgresFormat
 
 /// The data type's raw object ID.
 /// Use `select * from pg_type where oid = <idhere>;` to lookup more information.
-public struct PostgresDataType: RawRepresentable, Equatable, CustomStringConvertible {
+public struct PostgresDataType: RawRepresentable, Hashable, CustomStringConvertible {
     /// `0`
     public static let null = PostgresDataType(0)
     /// `16`

Sources/PostgresNIO/New/BufferedMessageEncoder.swift

@@ -1,21 +1,21 @@
 import NIOCore
 
-struct BufferedMessageEncoder<Encoder: MessageToByteEncoder> {
+struct BufferedMessageEncoder {
     private enum State {
         case flushed
         case writable
     }
 
     private var buffer: ByteBuffer
     private var state: State = .writable
-    private var encoder: Encoder
+    private var encoder: PSQLFrontendMessageEncoder
 
-    init(buffer: ByteBuffer, encoder: Encoder) {
+    init(buffer: ByteBuffer, encoder: PSQLFrontendMessageEncoder) {
         self.buffer = buffer
         self.encoder = encoder
     }
 
-    mutating func encode(_ message: Encoder.OutboundIn) throws {
+    mutating func encode(_ message: PSQLFrontendMessage) {
         switch self.state {
         case .flushed:
             self.state = .writable
@@ -25,7 +25,7 @@ struct BufferedMessageEncoder<Encoder: MessageToByteEncoder> {
             break
         }
 
-        try self.encoder.encode(data: message, out: &self.buffer)
+        self.encoder.encode(data: message, out: &self.buffer)
     }
 
     mutating func flush() -> ByteBuffer? {

Sources/PostgresNIO/New/Connection State Machine/ConnectionStateMachine.swift

@@ -84,8 +84,8 @@ struct ConnectionStateMachine {
         // Connection Actions
 
         // --- general actions
-        case sendParseDescribeBindExecuteSync(query: String, binds: [PSQLEncodable])
-        case sendBindExecuteSync(statementName: String, binds: [PSQLEncodable])
+        case sendParseDescribeBindExecuteSync(PostgresQuery)
+        case sendBindExecuteSync(PSQLExecuteStatement)
         case failQuery(ExtendedQueryContext, with: PSQLError, cleanupContext: CleanUpContext?)
         case succeedQuery(ExtendedQueryContext, columns: [RowDescription.Column])
         case succeedQueryNoRowsComming(ExtendedQueryContext, commandTag: String)
@@ -1050,11 +1050,11 @@ extension ConnectionStateMachine {
             }
 
             return false
-        case .decoding(_):
+        case .decoding:
             return true
-        case .unexpectedBackendMessage(_):
+        case .unexpectedBackendMessage:
             return true
-        case .unsupportedAuthMechanism(_):
+        case .unsupportedAuthMechanism:
             return true
         case .authMechanismRequiresPassword:
             return true
@@ -1106,10 +1106,10 @@ extension ConnectionStateMachine {
 extension ConnectionStateMachine {
     mutating func modify(with action: ExtendedQueryStateMachine.Action) -> ConnectionStateMachine.ConnectionAction {
         switch action {
-        case .sendParseDescribeBindExecuteSync(let query, let binds):
-            return .sendParseDescribeBindExecuteSync(query: query, binds: binds)
-        case .sendBindExecuteSync(let statementName, let binds):
-            return .sendBindExecuteSync(statementName: statementName, binds: binds)
+        case .sendParseDescribeBindExecuteSync(let query):
+            return .sendParseDescribeBindExecuteSync(query)
+        case .sendBindExecuteSync(let executeStatement):
+            return .sendBindExecuteSync(executeStatement)
         case .failQuery(let requestContext, with: let error):
             let cleanupContext = self.setErrorAndCreateCleanupContextIfNeeded(error)
             return .failQuery(requestContext, with: error, cleanupContext: cleanupContext)

Sources/PostgresNIO/New/Connection State Machine/ExtendedQueryStateMachine.swift

@@ -23,8 +23,8 @@ struct ExtendedQueryStateMachine {
     }
 
     enum Action {
-        case sendParseDescribeBindExecuteSync(query: String, binds: [PSQLEncodable])
-        case sendBindExecuteSync(statementName: String, binds: [PSQLEncodable])
+        case sendParseDescribeBindExecuteSync(PostgresQuery)
+        case sendBindExecuteSync(PSQLExecuteStatement)
 
         // --- general actions
         case failQuery(ExtendedQueryContext, with: PSQLError)
@@ -56,18 +56,18 @@ struct ExtendedQueryStateMachine {
         case .unnamed(let query):
             return self.avoidingStateMachineCoW { state -> Action in
                 state = .parseDescribeBindExecuteSyncSent(queryContext)
-                return .sendParseDescribeBindExecuteSync(query: query, binds: queryContext.bind)
+                return .sendParseDescribeBindExecuteSync(query)
             }
 
-        case .preparedStatement(let name, let rowDescription):
+        case .preparedStatement(let prepared):
             return self.avoidingStateMachineCoW { state -> Action in
-                switch rowDescription {
+                switch prepared.rowDescription {
                 case .some(let rowDescription):
                     state = .rowDescriptionReceived(queryContext, rowDescription.columns)
                 case .none:
                     state = .noDataMessageReceived(queryContext)
                 }
-                return .sendBindExecuteSync(statementName: name, binds: queryContext.bind)
+                return .sendBindExecuteSync(prepared)
             }
         }
     }

Sources/PostgresNIO/New/Data/Array+PSQLCodable.swift

@@ -76,7 +76,10 @@ extension Array: PSQLEncodable where Element: PSQLArrayElement {
         .binary
     }
 
-    func encode(into buffer: inout ByteBuffer, context: PSQLEncodingContext) throws {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into buffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) throws {
         // 0 if empty, 1 if not
         buffer.writeInteger(self.isEmpty ? 0 : 1, as: UInt32.self)
         // b

Sources/PostgresNIO/New/Data/Bool+PSQLCodable.swift

@@ -49,7 +49,10 @@ extension Bool: PSQLCodable {
         }
     }
 
-    func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into byteBuffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) {
         byteBuffer.writeInteger(self ? 1 : 0, as: UInt8.self)
     }
 }

Sources/PostgresNIO/New/Data/Bytes+PSQLCodable.swift

@@ -11,7 +11,10 @@ extension PSQLEncodable where Self: Sequence, Self.Element == UInt8 {
         .binary
     }
 
-    func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into byteBuffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) {
         byteBuffer.writeBytes(self)
     }
 }
@@ -25,7 +28,10 @@ extension ByteBuffer: PSQLCodable {
         .binary
     }
 
-    func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into byteBuffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) {
         var copyOfSelf = self // dirty hack
         byteBuffer.writeBuffer(&copyOfSelf)
     }
@@ -49,7 +55,10 @@ extension Data: PSQLCodable {
         .binary
     }
 
-    func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into byteBuffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) {
         byteBuffer.writeBytes(self)
     }
 

Sources/PostgresNIO/New/Data/Date+PSQLCodable.swift

@@ -34,9 +34,12 @@ extension Date: PSQLCodable {
         }
     }
 
-    func encode(into buffer: inout ByteBuffer, context: PSQLEncodingContext) {
+    func encode<JSONEncoder: PostgresJSONEncoder>(
+        into byteBuffer: inout ByteBuffer,
+        context: PSQLEncodingContext<JSONEncoder>
+    ) {
         let seconds = self.timeIntervalSince(Self._psqlDateStart) * Double(Self._microsecondsPerSecond)
-        buffer.writeInteger(Int64(seconds))
+        byteBuffer.writeInteger(Int64(seconds))
     }
 
     // MARK: Private Constants