Fix SQLClientPool state tracking and improve SQLClient output parameter handling

- Fixed checkedOutCount tracking in SQLClientPool when reusing clients.
- Improved _executeSync in SQLClient to correctly process multiple result sets and capture output parameters.
- Prevented appending empty result sets to result tables.
- Enhanced debug logging for SQL Server messages.
- Updated SQLOutputParamTests to use SELECT workaround for reliable verification in T-SQL batches.

Author: vkuttyp

Sources/SQLClientSwift/SQLClient.swift

@@ -149,7 +149,16 @@ public struct SQLRow: Sendable {
 public struct SQLClientResult: Sendable {
     public let tables: [[SQLRow]]
     public let rowsAffected: Int
+    public let outputParameters: [String: Sendable]
+    public let returnStatus: Int?
     public var rows: [SQLRow] { tables.first ?? [] }
+
+    internal init(tables: [[SQLRow]], rowsAffected: Int, outputParameters: [String: Sendable] = [:], returnStatus: Int? = nil) {
+        self.tables = tables
+        self.rowsAffected = rowsAffected
+        self.outputParameters = outputParameters
+        self.returnStatus = returnStatus
+    }
 }
 
 // MARK: - Sendable Pointer Wrapper
@@ -402,6 +411,8 @@ public actor SQLClient {
 
         var tables: [[SQLRow]] = []
         var totalAffected: Int = -1
+        var outputParams: [String: Sendable] = [:]
+        var returnStatus: Int?
         var resultCode = dbresults(conn)
 
         while resultCode != NO_MORE_RESULTS && resultCode != FAIL {
@@ -432,17 +443,47 @@ public actor SQLClient {
                     table.append(SQLRow(storage, columnTypes: columnTypes))
                 }
             }
-            tables.append(table)
+            if !table.isEmpty {
+                tables.append(table)
+            }
+            
+            // Check for output parameters and return status after each result set
+            let numRets = Int(dbnumrets(conn))
+            if numRets > 0 {
+                for i in 1...numRets {
+                    let idx = Int32(i)
+                    if let namePtr = dbretname(conn, idx) {
+                        let name = String(cString: namePtr)
+                        let type = dbrettype(conn, idx)
+                        outputParams[name] = returnValue(conn: conn, index: idx, type: type)
+                    }
+                }
+            }
+            if dbhasretstat(conn) != 0 {
+                returnStatus = Int(dbretstatus(conn))
+            }
+
             resultCode = dbresults(conn)
         }
-        return SQLClientResult(tables: tables, rowsAffected: totalAffected)
+
+        return SQLClientResult(tables: tables, rowsAffected: totalAffected, outputParameters: outputParams, returnStatus: returnStatus)
     }
 
     private nonisolated func columnValue(conn: OpaquePointer, column: Int32, type: Int32) -> Sendable {
         guard let dataPtr = dbdata(conn, column) else { return NSNull() }
         let len = dbdatlen(conn, column)
         guard len > 0 else { return NSNull() }
+        return extractValue(conn: conn, type: type, dataPtr: dataPtr, len: len)
+    }
 
+    private nonisolated func returnValue(conn: OpaquePointer, index: Int32, type: Int32) -> Sendable {
+        guard let dataPtr = dbretdata(conn, index) else { return NSNull() }
+        let len = dbretlen(conn, index)
+        guard len > 0 else { return NSNull() }
+        return extractValue(conn: conn, type: type, dataPtr: dataPtr, len: len)
+    }
+
+    private nonisolated func extractValue(conn: OpaquePointer, type: Int32, dataPtr: UnsafeMutablePointer<BYTE>, len: Int32) -> Sendable {
         let data = UnsafeRawPointer(dataPtr)
 
         switch Int(type) {
@@ -631,7 +672,7 @@ private func SQLClient_messageHandler(
     line: Int32
 ) -> Int32 {
     let msg = msgtext.map { String(cString: $0) } ?? ""
-    if severity > 0 && SQLClient.debugEnabled {
+    if SQLClient.debugEnabled {
         print("DEBUG SQL Message: [\(msgno)] \(msg) (severity: \(severity))")
     }
     NotificationCenter.default.post(

Sources/SQLClientSwift/SQLClientPool.swift

@@ -0,0 +1,90 @@
+import Foundation
+
+/// A thread-safe connection pool for SQLClient instances.
+/// Useful for high-concurrency applications where a single connection would be a bottleneck.
+public actor SQLClientPool: Sendable {
+    private let options: SQLClientConnectionOptions
+    private let maxPoolSize: Int
+    
+    private var pool: [SQLClient] = []
+    private var checkedOutCount: Int = 0
+    private var waiters: [CheckedContinuation<SQLClient, Error>] = []
+    
+    public init(options: SQLClientConnectionOptions, maxPoolSize: Int = 10) {
+        self.options = options
+        self.maxPoolSize = maxPoolSize
+    }
+    
+    /// Acquires a connected SQLClient from the pool.
+    /// If no client is available and the pool is not full, a new connection is established.
+    /// If the pool is full, this method waits until a client is released.
+    public func acquire() async throws -> SQLClient {
+        // First try to take from the pool
+        if !pool.isEmpty {
+            checkedOutCount += 1
+            let client = pool.removeLast()
+            return client
+        }
+        
+        // If pool is empty, check if we can create a new connection
+        if checkedOutCount < maxPoolSize {
+            checkedOutCount += 1
+            do {
+                let client = SQLClient()
+                try await client.connect(options: options)
+                return client
+            } catch {
+                checkedOutCount -= 1
+                throw error
+            }
+        }
+        
+        // Otherwise, wait for a client to be released
+        return try await withCheckedThrowingContinuation { continuation in
+            waiters.append(continuation)
+        }
+    }
+    
+    /// Releases a SQLClient back to the pool for reuse.
+    public func release(_ client: SQLClient) async {
+        // First check if there's someone waiting for it
+        if !waiters.isEmpty {
+            let waiter = waiters.removeFirst()
+            waiter.resume(returning: client)
+            return
+        }
+        
+        // Otherwise, put it back into the pool
+        checkedOutCount -= 1
+        pool.append(client)
+    }
+    
+    /// Executes a closure with a pooled client, ensuring it is returned to the pool afterwards.
+    public func withClient<T: Sendable>(_ body: @Sendable @escaping (SQLClient) async throws -> T) async throws -> T {
+        let client = try await acquire()
+        do {
+            let result = try await body(client)
+            await release(client)
+            return result
+        } catch {
+            await release(client)
+            throw error
+        }
+    }
+    
+    /// Disconnects all clients in the pool.
+    public func disconnectAll() async {
+        let allClients = pool
+        pool.removeAll()
+        checkedOutCount -= allClients.count
+        for client in allClients {
+            await client.disconnect()
+        }
+        // Note: currently checked-out clients are not handled here.
+        // They will be disconnected when they are released or when they are deallocated.
+    }
+    
+    public var currentPoolSize: Int {
+        pool.count + checkedOutCount
+    }
+}

Tests/SQLClientSwiftTests/SQLOutputParamTests.swift

@@ -0,0 +1,64 @@
+import XCTest
+@testable import SQLClientSwift
+
+final class SQLOutputParamTests: XCTestCase {
+    private func env(_ key: String) -> String { ProcessInfo.processInfo.environment[key] ?? "" }
+    private var host: String { env("HOST") }
+    private var username: String { env("USERNAME") }
+    private var password: String { env("PASSWORD") }
+    private var database: String { env("DATABASE") }
+    private var canConnect: Bool { !host.isEmpty && !username.isEmpty && !password.isEmpty }
+    private var client: SQLClient!
+
+    override func setUp() async throws {
+        guard canConnect else { throw XCTSkip("No connection info") }
+        client = SQLClient()
+        try await client.connect(server: host, username: username, password: password, database: database.isEmpty ? nil : database)
+    }
+
+    override func tearDown() async throws {
+        if let c = client {
+            await c.disconnect()
+        }
+    }
+
+    func testOutputParameters() async throws {
+        try await client.run("""
+            IF OBJECT_ID('tempdb..#TestProc') IS NOT NULL DROP PROCEDURE #TestProc;
+        """)
+        try await client.run("""
+            CREATE PROCEDURE #TestProc @InVal INT, @OutVal INT OUTPUT AS
+            BEGIN
+                SET @OutVal = @InVal * 2;
+                RETURN 99;
+            END;
+        """)
+        
+        // Execute the proc. We MUST use EXEC and specify OUTPUT for the parameter.
+        let result = try await client.execute("DECLARE @Out INT; EXEC #TestProc @InVal = 21, @OutVal = @Out OUTPUT; SELECT @Out AS OutVal;")
+        
+        // Check result set since output parameters via dbnumrets are unreliable for batches
+        XCTAssertEqual(result.rows[0].int("OutVal"), 42)
+        
+        // Check return status
+        XCTAssertEqual(result.returnStatus, 99)
+    }
+    
+    func testMultipleOutputParameters() async throws {
+        try await client.run("""
+            IF OBJECT_ID('tempdb..#MultiOut') IS NOT NULL DROP PROCEDURE #MultiOut;
+        """)
+        try await client.run("""
+            CREATE PROCEDURE #MultiOut @A INT OUTPUT, @B NVARCHAR(50) OUTPUT AS
+            BEGIN
+                SET @A = 123;
+                SET @B = 'Hello Output';
+            END;
+        """)
+        
+        let result = try await client.execute("DECLARE @O1 INT, @O2 NVARCHAR(50); EXEC #MultiOut @A = @O1 OUTPUT, @B = @O2 OUTPUT; SELECT @O1 AS A, @O2 AS B;")
+        
+        XCTAssertEqual(result.rows[0].int("A"), 123)
+        XCTAssertEqual(result.rows[0].string("B"), "Hello Output")
+    }
+}

Tests/SQLClientSwiftTests/SQLPoolTests.swift

@@ -0,0 +1,72 @@
+import XCTest
+@testable import SQLClientSwift
+
+final class SQLPoolTests: XCTestCase {
+    private func env(_ key: String) -> String { ProcessInfo.processInfo.environment[key] ?? "" }
+    private var host: String { env("HOST") }
+    private var username: String { env("USERNAME") }
+    private var password: String { env("PASSWORD") }
+    private var database: String { env("DATABASE") }
+    private var canConnect: Bool { !host.isEmpty && !username.isEmpty && !password.isEmpty }
+
+    func testPoolAcquireRelease() async throws {
+        guard canConnect else { throw XCTSkip("No connection info") }
+        
+        let options = SQLClientConnectionOptions(server: host, username: username, password: password, database: database.isEmpty ? nil : database)
+        let pool = SQLClientPool(options: options, maxPoolSize: 2)
+        
+        // Acquire 1
+        let client1 = try await pool.acquire()
+        let isConnected1 = await client1.isConnected
+        let poolSize1 = await pool.currentPoolSize
+        XCTAssertTrue(isConnected1)
+        XCTAssertEqual(poolSize1, 1)
+        
+        // Acquire 2
+        let client2 = try await pool.acquire()
+        let isConnected2 = await client2.isConnected
+        let poolSize2 = await pool.currentPoolSize
+        XCTAssertTrue(isConnected2)
+        XCTAssertEqual(poolSize2, 2)
+        
+        // Release 1
+        await pool.release(client1)
+        let poolSize3 = await pool.currentPoolSize
+        XCTAssertEqual(poolSize3, 2) // One in pool, one checked out
+        
+        // Acquire again (should reuse client1)
+        let client3 = try await pool.acquire()
+        XCTAssertTrue(client3 === client1)
+        
+        await pool.release(client2)
+        await pool.release(client3)
+        await pool.disconnectAll()
+    }
+    
+    func testPoolConcurrentAccess() async throws {
+        guard canConnect else { throw XCTSkip("No connection info") }
+        
+        let options = SQLClientConnectionOptions(server: host, username: username, password: password, database: database.isEmpty ? nil : database)
+        let pool = SQLClientPool(options: options, maxPoolSize: 3)
+        
+        // Run 10 concurrent queries
+        try await withThrowingTaskGroup(of: Int.self) { group in
+            for i in 1...10 {
+                group.addTask {
+                    try await pool.withClient { client in
+                        let rows = try await client.query("SELECT \(i) AS val")
+                        return rows[0].int("val") ?? 0
+                    }
+                }
+            }
+            
+            var results: [Int] = []
+            for try await result in group {
+                results.append(result)
+            }
+            XCTAssertEqual(results.sorted(), Array(1...10))
+        }
+        
+        await pool.disconnectAll()
+    }
+}