Use PSQLFormat when encoding and decoding

Sources/PostgresNIO/Connection/PostgresConnection+Database.swift

@@ -23,7 +23,7 @@ extension PostgresConnection: PostgresDatabase {
                         dataType: PostgresDataType(UInt32(column.dataType.rawValue)),
                         dataTypeSize: column.dataTypeSize,
                         dataTypeModifier: column.dataTypeModifier,
-                        formatCode: .init(psqlFormatCode: column.formatCode)
+                        formatCode: .init(psqlFormatCode: column.format)
                     )
                 }
 

Sources/PostgresNIO/Connection/PostgresDatabase+PreparedQuery.swift

@@ -43,7 +43,7 @@ public struct PreparedQuery {
                     dataType: PostgresDataType(UInt32(column.dataType.rawValue)),
                     dataTypeSize: column.dataTypeSize,
                     dataTypeModifier: column.dataTypeModifier,
-                    formatCode: .init(psqlFormatCode: column.formatCode)
+                    formatCode: .init(psqlFormatCode: column.format)
                 )
             }
 

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

@@ -114,7 +114,20 @@ struct ExtendedQueryStateMachine {
         }
 
         return self.avoidingStateMachineCoW { state -> Action in
-            state = .rowDescriptionReceived(queryContext, rowDescription.columns)
+            // In Postgres extended queries we receive the `rowDescription` before we send the
+            // `Bind` message. Well actually it's vice versa, but this is only true since we do
+            // pipelining during a query.
+            //
+            // In the actual protocol description we receive a rowDescription before the Bind
+
+            // In Postgres extended queries we always request the response rows to be returned in
+            // `.binary` format.
+            let columns = rowDescription.columns.map { column -> PSQLBackendMessage.RowDescription.Column in                
+                var column = column
+                column.format = .binary
+                return column
+            }
+            state = .rowDescriptionReceived(queryContext, columns)
             return .wait
         }
     }
@@ -157,7 +170,7 @@ struct ExtendedQueryStateMachine {
 
             return self.avoidingStateMachineCoW { state -> Action in
                 let row = dataRow.columns.enumerated().map { (index, buffer) in
-                    PSQLData(bytes: buffer, dataType: columns[index].dataType)
+                    PSQLData(bytes: buffer, dataType: columns[index].dataType, format: columns[index].format)
                 }
                 buffer.append(row)
                 state = .bufferingRows(columns, buffer, readOnEmpty: readOnEmpty)
@@ -174,7 +187,7 @@ struct ExtendedQueryStateMachine {
             return self.avoidingStateMachineCoW { state -> Action in
                 precondition(buffer.isEmpty, "Expected the buffer to be empty")
                 let row = dataRow.columns.enumerated().map { (index, buffer) in
-                    PSQLData(bytes: buffer, dataType: columns[index].dataType)
+                    PSQLData(bytes: buffer, dataType: columns[index].dataType, format: columns[index].format)
                 }
 
                 state = .bufferingRows(columns, buffer, readOnEmpty: false)

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

@@ -72,6 +72,10 @@ extension Array: PSQLEncodable where Element: PSQLArrayElement {
         Element.psqlArrayType
     }
 
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
     func encode(into buffer: inout ByteBuffer, context: PSQLEncodingContext) throws {
         // 0 if empty, 1 if not
         buffer.writeInteger(self.isEmpty ? 0 : 1, as: UInt32.self)
@@ -98,7 +102,12 @@ extension Array: PSQLEncodable where Element: PSQLArrayElement {
 
 extension Array: PSQLDecodable where Element: PSQLArrayElement {
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Array<Element> {
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Array<Element> {
+        guard case .binary = format else {
+            // currently we only support decoding arrays in binary format.
+            throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+        }
+
         guard let isNotEmpty = buffer.readInteger(as: Int32.self), (0...1).contains(isNotEmpty) else {
             throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
         }
@@ -135,7 +144,7 @@ extension Array: PSQLDecodable where Element: PSQLArrayElement {
                 throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
             }
 
-            let element = try Element.decode(from: &elementBuffer, type: elementType, context: context)
+            let element = try Element.decode(from: &elementBuffer, type: elementType, format: format, context: context)
 
             result.append(element)
         }

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

@@ -3,18 +3,42 @@ extension Bool: PSQLCodable {
         .bool
     }
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Bool {
-        guard type == .bool, buffer.readableBytes == 1 else {
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Bool {
+        guard type == .bool else {
             throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
         }
 
-        switch buffer.readInteger(as: UInt8.self) {
-        case .some(0):
-            return false
-        case .some(1):
-            return true
-        default:
-            throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+        switch format {
+        case .binary:
+            guard buffer.readableBytes == 1 else {
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
+
+            switch buffer.readInteger(as: UInt8.self) {
+            case .some(0):
+                return false
+            case .some(1):
+                return true
+            default:
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
+        case .text:
+            guard buffer.readableBytes == 1 else {
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
+
+            switch buffer.readInteger(as: UInt8.self) {
+            case .some(UInt8(ascii: "f")):
+                return false
+            case .some(UInt8(ascii: "t")):
+                return true
+            default:
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
         }
     }
 

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

@@ -6,6 +6,10 @@ extension PSQLEncodable where Self: Sequence, Self.Element == UInt8 {
         .bytea
     }
 
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
     func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
         byteBuffer.writeBytes(self)
     }
@@ -16,12 +20,16 @@ extension ByteBuffer: PSQLCodable {
         .bytea
     }
 
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
     func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
         var copyOfSelf = self // dirty hack
         byteBuffer.writeBuffer(&copyOfSelf)
     }
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Self {
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Self {
         return buffer
     }
 }
@@ -30,12 +38,16 @@ extension Data: PSQLCodable {
     var psqlType: PSQLDataType {
         .bytea
     }
-
+
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
     func encode(into byteBuffer: inout ByteBuffer, context: PSQLEncodingContext) {
         byteBuffer.writeBytes(self)
     }
-    
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Self {
+
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Self {
         return buffer.readData(length: buffer.readableBytes, byteTransferStrategy: .automatic)!
     }
 }

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

@@ -5,7 +5,11 @@ extension Date: PSQLCodable {
         .timestamptz
     }
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Self {
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Self {
         switch type {
         case .timestamp, .timestamptz:
             guard buffer.readableBytes == 8, let microseconds = buffer.readInteger(as: Int64.self) else {

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

@@ -3,18 +3,27 @@ extension Float: PSQLCodable {
         .float4
     }
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Float {
-        switch type {
-        case .float4:
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Float {
+        switch (format, type) {
+        case (.binary, .float4):
             guard buffer.readableBytes == 4, let float = buffer.readFloat() else {
                 throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
             }
             return float
-        case .float8:
+        case (.binary, .float8):
             guard buffer.readableBytes == 8, let double = buffer.readDouble() else {
                 throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
             }
             return Float(double)
+        case (.text, .float4), (.text, .float8):
+            guard let string = buffer.readString(length: buffer.readableBytes), let value = Float(string) else {
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
+            return value
         default:
             throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
         }
@@ -30,18 +39,27 @@ extension Double: PSQLCodable {
         .float8
     }
 
-    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, context: PSQLDecodingContext) throws -> Double {
-        switch type {
-        case .float4:
+    var psqlFormat: PSQLFormat {
+        .binary
+    }
+
+    static func decode(from buffer: inout ByteBuffer, type: PSQLDataType, format: PSQLFormat, context: PSQLDecodingContext) throws -> Double {
+        switch (format, type) {
+        case (.binary, .float4):
             guard buffer.readableBytes == 4, let float = buffer.readFloat() else {
                 throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
             }
             return Double(float)
-        case .float8:
+        case (.binary, .float8):
             guard buffer.readableBytes == 8, let double = buffer.readDouble() else {
                 throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
             }
             return double
+        case (.text, .float4), (.text, .float8):
+            guard let string = buffer.readString(length: buffer.readableBytes), let value = Double(string) else {
+                throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
+            }
+            return value
         default:
             throw PSQLCastingError.failure(targetType: Self.self, type: type, postgresData: buffer, context: context)
         }