fixes vapor#24. combines parameterized query phases into one

Author: tanner0101

Sources/PostgreSQL/Connection/PostgreSQLConnection+Query.swift

@@ -28,52 +28,44 @@ extension PostgreSQLConnection {
             query: string,
             parameterTypes: parameters.map { $0.type }
         )
-        let describe = PostgreSQLDescribeRequest(type: .statement, name: "")
+        let describe = PostgreSQLDescribeRequest(
+            type: .statement,
+            name: ""
+        )
+        let bind = PostgreSQLBindRequest(
+            portalName: "",
+            statementName: "",
+            parameterFormatCodes: parameters.map { $0.format },
+            parameters: parameters.map { .init(data: $0.data) },
+            resultFormatCodes: resultFormat.formatCodes
+        )
+        let execute = PostgreSQLExecuteRequest(
+            portalName: "",
+            maxRows: 0
+        )
+
         var currentRow: PostgreSQLRowDescription?
-        
-        return send([
-            .parse(parse), .describe(describe), .sync
+        return self.send([
+            .parse(parse), .describe(describe), .bind(bind), .execute(execute), .sync
         ]) { message in
             switch message {
             case .parseComplete: break
-            case .rowDescription(let row): currentRow = row
             case .parameterDescription: break
             case .noData: break
-            default: throw PostgreSQLError(identifier: "query", reason: "Unexpected message during PostgreSQLParseRequest: \(message)", source: .capture())
-            }
-        }.flatMap(to: Void.self) {
-            let resultFormats = resultFormat.formatCodeFactory(currentRow?.fields.map { $0.dataType } ?? [])
-            // cache so we don't compute twice
-            let bind = PostgreSQLBindRequest(
-                portalName: "",
-                statementName: "",
-                parameterFormatCodes: parameters.map { $0.format },
-                parameters: parameters.map { .init(data: $0.data) },
-                resultFormatCodes: resultFormats
-            )
-            let execute = PostgreSQLExecuteRequest(
-                portalName: "",
-                maxRows: 0
-            )
-            return self.send([
-                .bind(bind), .execute(execute), .sync
-            ]) { message in
-                switch message {
-                case .bindComplete: break
-                case .dataRow(let data):
-                    guard let row = currentRow else {
-                        throw PostgreSQLError(identifier: "query", reason: "Unexpected PostgreSQLDataRow without preceding PostgreSQLRowDescription.", source: .capture())
-                    }
-                    let parsed = try row.parse(
-                        data: data,
-                        formatCodes: resultFormats,
-                        tableNameCache: self.tableNameCache
-                    )
-                    try onRow(parsed)
-                case .close: break
-                case .noData: break
-                default: throw PostgreSQLError(identifier: "query", reason: "Unexpected message during PostgreSQLParseRequest: \(message)", source: .capture())
+            case .bindComplete: break
+            case .rowDescription(let row): currentRow = row
+            case .dataRow(let data):
+                guard let row = currentRow else {
+                    throw PostgreSQLError(identifier: "query", reason: "Unexpected PostgreSQLDataRow without preceding PostgreSQLRowDescription.", source: .capture())
                 }
+                let parsed = try row.parse(
+                    data: data,
+                    formatCodes: resultFormat.formatCodes,
+                    tableNameCache: self.tableNameCache
+                )
+                try onRow(parsed)
+            case .close: break
+            default: throw PostgreSQLError(identifier: "query", reason: "Unexpected message during PostgreSQLParseRequest: \(message)", source: .capture())
             }
         }
     }

Sources/PostgreSQL/Connection/PostgreSQLConnection.swift

@@ -20,10 +20,26 @@ public final class PostgreSQLConnection {
     /// Caches oid -> table name data.
     internal var tableNameCache: PostgreSQLTableNameCache?
 
+    /// Returns a new unique portal name.
+    internal var nextPortalName: String {
+        defer { uniqueNameCounter = uniqueNameCounter &+ 1 }
+        return "p_\(uniqueNameCounter)"
+    }
+
+    /// Returns a new unique statement name.
+    internal var nextStatementName: String {
+        defer { uniqueNameCounter = uniqueNameCounter &+ 1 }
+        return "s_\(uniqueNameCounter)"
+    }
+
+    /// A unique identifier for this connection, used to generate statment and portal names
+    private var uniqueNameCounter: UInt8
+
     /// Creates a new Redis client on the provided data source and sink.
     init(queue: QueueHandler<PostgreSQLMessage, PostgreSQLMessage>, channel: Channel) {
         self.queue = queue
         self.channel = channel
+        self.uniqueNameCounter = 0
     }
 
     /// Sends `PostgreSQLMessage` to the server.

Sources/PostgreSQL/DataType/PostgreSQLFormatCode.swift

@@ -9,16 +9,11 @@ public enum PostgreSQLFormatCode: Int16, Codable {
 
 public struct PostgreSQLResultFormat {
     /// The format codes
-    internal let formatCodeFactory: ([PostgreSQLDataType]) -> [PostgreSQLFormatCode]
-
-    /// Dynamically choose result format based on data type.
-    public static func dynamic(_ callback: @escaping (PostgreSQLDataType) -> PostgreSQLFormatCode) -> PostgreSQLResultFormat {
-        return .init { return $0.map { callback($0) } }
-    }
+    internal let formatCodes: [PostgreSQLFormatCode]
 
     /// Request all of the results in a specific format.
     public static func all(_ code: PostgreSQLFormatCode) -> PostgreSQLResultFormat {
-        return .init { _ in return [code] }
+        return .init(formatCodes: [code])
     }
 
     /// Request all of the results in a specific format.
@@ -33,6 +28,11 @@ public struct PostgreSQLResultFormat {
 
     /// Let the server decide the formatting options.
     public static func notSpecified() -> PostgreSQLResultFormat {
-        return .init { _ in return [] }
+        return .init(formatCodes: [])
+    }
+
+    /// Request all of the results in a specific format.
+    public static func specific(_ codes: [PostgreSQLFormatCode]) -> PostgreSQLResultFormat {
+        return .init(formatCodes: codes)
     }
 }

Sources/PostgreSQL/Message/PostgreSQLDataRow.swift

@@ -33,3 +33,13 @@ struct PostgreSQLDataRowColumn: Decodable {
         return PostgreSQLData(type: dataType, format: format, data: value)
     }
 }
+
+extension PostgreSQLDataRowColumn: CustomStringConvertible {
+    var description: String {
+        if let value = value {
+            return String(data: value, encoding: .ascii) ?? value.hexDebug
+        } else {
+            return "<null>"
+        }
+    }
+}

Tests/PostgreSQLTests/PostgreSQLConnectionTests.swift

@@ -286,6 +286,61 @@ class PostgreSQLConnectionTests: XCTestCase {
         XCTAssertEqual(parameterizedResult.count, 1)
     }
 
+    func testGH24() throws {
+        /// PREPARE
+        let client = try PostgreSQLConnection.makeTest()
+        _ = try client.query("""
+        DROP TABLE IF EXISTS "acronym+category"
+        """).wait()
+        _ = try client.query("""
+        DROP TABLE IF EXISTS "categories"
+        """).wait()
+        _ = try client.query("""
+        DROP TABLE IF EXISTS "acronyms"
+        """).wait()
+        _ = try client.query("""
+        DROP TABLE IF EXISTS "users"
+        """).wait()
+
+        /// CREATE
+        let _ = try client.query("""
+        CREATE TABLE "users" ("id" UUID PRIMARY KEY, "name" TEXT NOT NULL, "username" TEXT NOT NULL)
+        """).wait()
+        let _ = try client.query("""
+        CREATE TABLE "acronyms" ("id" BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "short" TEXT NOT NULL, "long" TEXT NOT NULL, "userID" UUID NOT NULL, FOREIGN KEY ("userID") REFERENCES "users" ("id"), FOREIGN KEY ("userID") REFERENCES "users" ("id"))
+        """).wait()
+        let _ = try client.query("""
+        CREATE TABLE "categories" ("id" BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, "name" TEXT NOT NULL)
+        """).wait()
+        let _ = try client.query("""
+        CREATE TABLE "acronym+category" ("id" UUID PRIMARY KEY, "acronymID" BIGINT NOT NULL, "categoryID" BIGINT NOT NULL, FOREIGN KEY ("acronymID") REFERENCES "acronyms" ("id"), FOREIGN KEY ("categoryID") REFERENCES "categories" ("id"), FOREIGN KEY ("acronymID") REFERENCES "acronyms" ("id"), FOREIGN KEY ("categoryID") REFERENCES "categories" ("id"))
+        """).wait()
+
+        /// INSERT
+        let userUUID = UUID()
+        let _ = try client.query("""
+        INSERT INTO "users" ("id", "name", "username") VALUES ($1, $2, $3)
+        """, [userUUID, "Vapor Test", "vapor"]).wait()
+        let _ = try client.query("""
+        INSERT INTO "acronyms" ("id", "userID", "short", "long") VALUES ($1, $2, $3, $4)
+        """, [1, userUUID, "ilv", "i love vapor"]).wait()
+        let _ = try client.query("""
+        INSERT INTO "categories" ("id", "name") VALUES ($1, $2);
+        """, [1, "all"]).wait()
+
+
+        /// SELECT
+        let acronyms = try client.query("""
+        SELECT "acronyms".* FROM "acronyms" WHERE ("acronyms"."id" = $1) LIMIT 1 OFFSET 0
+        """, [1])
+        let categories = try client.query("""
+        SELECT "categories".* FROM "categories" WHERE ("categories"."id" = $1) LIMIT 1 OFFSET 0
+        """, [1])
+
+        try print(acronyms.wait())
+        try print(categories.wait())
+    }
+
     static var allTests = [
         ("testVersion", testVersion),
         ("testSelectTypes", testSelectTypes),
@@ -294,6 +349,7 @@ class PostgreSQLConnectionTests: XCTestCase {
         ("testParameterizedTypes", testParameterizedTypes),
         ("testStruct", testStruct),
         ("testNull", testNull),
+        ("testGH24", testGH24),
     ]
 }