Increase bind parameters limit (#298)

Author: MahdiBM

Sources/PostgresNIO/Connection/PostgresConnection.swift

@@ -309,7 +309,7 @@ public final class PostgresConnection {
     private func queryStream(_ query: PostgresQuery, logger: Logger) -> EventLoopFuture<PSQLRowStream> {
         var logger = logger
         logger[postgresMetadataKey: .connectionID] = "\(self.id)"
-        guard query.binds.count <= Int(Int16.max) else {
+        guard query.binds.count <= Int(UInt16.max) else {
             return self.channel.eventLoop.makeFailedFuture(PSQLError.tooManyParameters)
         }
 
@@ -341,7 +341,7 @@ public final class PostgresConnection {
     }
 
     func execute(_ executeStatement: PSQLExecuteStatement, logger: Logger) -> EventLoopFuture<PSQLRowStream> {
-        guard executeStatement.binds.count <= Int(Int16.max) else {
+        guard executeStatement.binds.count <= Int(UInt16.max) else {
             return self.channel.eventLoop.makeFailedFuture(PSQLError.tooManyParameters)
         }
         let promise = self.channel.eventLoop.makePromise(of: PSQLRowStream.self)
@@ -498,7 +498,7 @@ extension PostgresConnection {
         var logger = logger
         logger[postgresMetadataKey: .connectionID] = "\(self.id)"
 
-        guard query.binds.count <= Int(Int16.max) else {
+        guard query.binds.count <= Int(UInt16.max) else {
             throw PSQLError.tooManyParameters
         }
         let promise = self.channel.eventLoop.makePromise(of: PSQLRowStream.self)

Sources/PostgresNIO/New/Messages/Bind.swift

@@ -20,14 +20,14 @@ extension PostgresFrontendMessage {
             // zero to indicate that there are no parameters or that the parameters all use the
             // default format (text); or one, in which case the specified format code is applied
             // to all parameters; or it can equal the actual number of parameters.
-            buffer.writeInteger(Int16(self.bind.count))
+            buffer.writeInteger(UInt16(self.bind.count))
 
             // The parameter format codes. Each must presently be zero (text) or one (binary).
             self.bind.metadata.forEach {
                 buffer.writeInteger($0.format.rawValue)
             }
 
-            buffer.writeInteger(Int16(self.bind.count))
+            buffer.writeInteger(UInt16(self.bind.count))
 
             var parametersCopy = self.bind.bytes
             buffer.writeBuffer(&parametersCopy)

Sources/PostgresNIO/New/Messages/ParameterDescription.swift

@@ -7,10 +7,7 @@ extension PostgresBackendMessage {
         var dataTypes: [PostgresDataType]
 
         static func decode(from buffer: inout ByteBuffer) throws -> Self {
-            let parameterCount = try buffer.throwingReadInteger(as: Int16.self)
-            guard parameterCount >= 0 else {
-                throw PSQLPartialDecodingError.integerMustBePositiveOrNull(parameterCount)
-            }
+            let parameterCount = try buffer.throwingReadInteger(as: UInt16.self)
 
             var result = [PostgresDataType]()
             result.reserveCapacity(Int(parameterCount))

Sources/PostgresNIO/New/Messages/Parse.swift

@@ -15,7 +15,7 @@ extension PostgresFrontendMessage {
         func encode(into buffer: inout ByteBuffer) {
             buffer.writeNullTerminatedString(self.preparedStatementName)
             buffer.writeNullTerminatedString(self.query)
-            buffer.writeInteger(Int16(self.parameters.count))
+            buffer.writeInteger(UInt16(self.parameters.count))
 
             self.parameters.forEach { dataType in
                 buffer.writeInteger(dataType.rawValue)

Tests/IntegrationTests/PSQLIntegrationTests.swift

@@ -329,4 +329,60 @@ final class IntegrationTests: XCTestCase {
             XCTAssertEqual(obj?.bar, 2)
         }
     }
+    
+#if swift(>=5.5.2)
+    func testBindMaximumParameters() async throws {
+        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer { XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully()) }
+        let eventLoop = eventLoopGroup.next()
+        
+        try await withTestConnection(on: eventLoop) { connection in
+            // Max binds limit is UInt16.max which is 65535 which is 3 * 5 * 17 * 257
+            // Max columns limit is 1664, so we will only make 5 * 257 columns which is less
+            // Then we will insert 3 * 17 rows
+            // In the insertion, there will be a total of 3 * 17 * 5 * 257 == UInt16.max bindings
+            // If the test is successful, it means Postgres supports UInt16.max bindings
+            let columnsCount = 5 * 257
+            let rowsCount = 3 * 17
+            
+            let createQuery = PostgresQuery(
+                unsafeSQL: """
+                CREATE TABLE table1 (
+                \((0..<columnsCount).map({ #""int\#($0)" int NOT NULL"# }).joined(separator: ", "))
+                );
+                """
+            )
+            try await connection.query(createQuery, logger: .psqlTest)
+            
+            var binds = PostgresBindings(capacity: Int(UInt16.max))
+            for _ in (0..<rowsCount) {
+                for num in (0..<columnsCount) {
+                    try binds.append(num, context: .default)
+                }
+            }
+            XCTAssertEqual(binds.count, Int(UInt16.max))
+            
+            let insertionValues = (0..<rowsCount).map { rowIndex in
+                let indices = (0..<columnsCount).map { columnIndex -> String in
+                    "$\(rowIndex * columnsCount + columnIndex + 1)"
+                }
+                return "(\(indices.joined(separator: ", ")))"
+            }.joined(separator: ", ")
+            let insertionQuery = PostgresQuery(
+                unsafeSQL: "INSERT INTO table1 VALUES \(insertionValues)",
+                binds: binds
+            )
+            try await connection.query(insertionQuery, logger: .psqlTest)
+            
+            let countQuery = PostgresQuery(unsafeSQL: "SELECT COUNT(*) FROM table1")
+            let countRows = try await connection.query(countQuery, logger: .psqlTest)
+            var countIterator = countRows.makeAsyncIterator()
+            let insertedRowsCount = try await countIterator.next()?.decode(Int.self, context: .default)
+            XCTAssertEqual(rowsCount, insertedRowsCount)
+            
+            let dropQuery = PostgresQuery(unsafeSQL: "DROP TABLE table1")
+            try await connection.query(dropQuery, logger: .psqlTest)
+        }
+    }
+#endif
 }

Tests/IntegrationTests/PostgresNIOTests.swift

@@ -1061,7 +1061,7 @@ final class PostgresNIOTests: XCTestCase {
         var conn: PostgresConnection?
         XCTAssertNoThrow(conn = try PostgresConnection.test(on: eventLoop).wait())
         defer { XCTAssertNoThrow( try conn?.close().wait() ) }
-        let binds = [PostgresData].init(repeating: .null, count: Int(Int16.max) + 1)
+        let binds = [PostgresData].init(repeating: .null, count: Int(UInt16.max) + 1)
         XCTAssertThrowsError(try conn?.query("SELECT version()", binds).wait()) { error in
             guard case .tooManyParameters = (error as? PSQLError)?.base else {
                 return XCTFail("Unexpected error: \(error)")

Tests/PostgresNIOTests/New/Messages/ParseTests.swift

@@ -26,7 +26,7 @@ class ParseTests: XCTestCase {
         XCTAssertEqual(byteBuffer.readInteger(as: Int32.self), Int32(length - 1))
         XCTAssertEqual(byteBuffer.readNullTerminatedString(), parse.preparedStatementName)
         XCTAssertEqual(byteBuffer.readNullTerminatedString(), parse.query)
-        XCTAssertEqual(byteBuffer.readInteger(as: Int16.self), Int16(parse.parameters.count))
+        XCTAssertEqual(byteBuffer.readInteger(as: UInt16.self), UInt16(parse.parameters.count))
         XCTAssertEqual(byteBuffer.readInteger(as: UInt32.self), PostgresDataType.bool.rawValue)
         XCTAssertEqual(byteBuffer.readInteger(as: UInt32.self), PostgresDataType.int8.rawValue)
         XCTAssertEqual(byteBuffer.readInteger(as: UInt32.self), PostgresDataType.bytea.rawValue)