perf: four targeted optimizations

1. Static DateFormatter/ISO8601DateFormatter singletons in pgDecode() and
   mysqlDecode() — eliminates per-cell formatter construction (was ~1ms each).
   Also static formatter in pgLiteral for date→SQL conversion.

2. Pre-compute sqlCols [SQLColumn] once per RowDescription in Postgres
   collectResults() and queryMulti() — was re-allocated on every data row.

3. MSSQL sendPacket: write chunks without flushing, flush only on last
   chunk (writeAndFlush) — reduces event-loop round-trips for multi-packet
   large queries.

4. SQLDataTable: O(n) columnIndex(for:) replaced with O(1) dictionary lookup
   built once at init. Applies to subscript[row, column: String] and
   column(named:).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: vkuttyp

Sources/CosmoMSSQL/MSSQLConnection.swift

@@ -645,7 +645,12 @@ public final class MSSQLConnection: SQLDatabase, @unchecked Sendable {
             header.encode(into: &pkt)
             pkt.writeBytes(payload.getBytes(at: payload.readerIndex + offset, length: chunkLen)!)
 
-            try await channel.writeAndFlush(pkt).get()
+            if isLast {
+                // Last chunk: writeAndFlush sends all buffered writes in one TCP segment
+                try await channel.writeAndFlush(pkt).get()
+            } else {
+                channel.write(pkt, promise: nil)
+            }
             packetID = packetID == 255 ? 1 : packetID + 1
             offset += chunkLen
         }

Sources/CosmoMySQL/Protocol/MySQLDecoder.swift

@@ -183,6 +183,17 @@ func mysqlCachingSHA2Password(password: String, nonce: [UInt8]) -> [UInt8] {
 
 // MARK: - MySQL type → SQLValue
 
+// Static formatters — DateFormatter construction is expensive; allocating one per cell
+// (old behaviour) added significant overhead for date/datetime-heavy result sets.
+private nonisolated(unsafe) let _mysqlDateFmt: DateFormatter = {
+    let f = DateFormatter(); f.locale = Locale(identifier: "en_US_POSIX")
+    f.dateFormat = "yyyy-MM-dd"; return f
+}()
+private nonisolated(unsafe) let _mysqlDateTimeFmt: DateFormatter = {
+    let f = DateFormatter(); f.locale = Locale(identifier: "en_US_POSIX")
+    f.dateFormat = "yyyy-MM-dd HH:mm:ss"; return f
+}()
+
 func mysqlDecode(columnType: UInt8, isUnsigned: Bool, text: String?) -> SQLValue {
     guard let text = text else { return .null }
     switch columnType {
@@ -206,11 +217,9 @@ func mysqlDecode(columnType: UInt8, isUnsigned: Bool, text: String?) -> SQLValue
     case 0xFE where text.count == 36:  // CHAR(36) — likely UUID
         return UUID(uuidString: text).map { .uuid($0) } ?? .string(text)
     case 0x0A:  // DATE
-        let fmt = DateFormatter(); fmt.dateFormat = "yyyy-MM-dd"
-        return fmt.date(from: text).map { .date($0) } ?? .string(text)
+        return _mysqlDateFmt.date(from: text).map { .date($0) } ?? .string(text)
     case 0x0B, 0x0C, 0x07: // TIME, DATETIME, TIMESTAMP
-        let fmt = DateFormatter(); fmt.dateFormat = "yyyy-MM-dd HH:mm:ss"
-        return fmt.date(from: text).map { .date($0) } ?? .string(text)
+        return _mysqlDateTimeFmt.date(from: text).map { .date($0) } ?? .string(text)
     default:
         return .string(text)
     }

Sources/CosmoPostgres/PostgresConnection.swift

@@ -307,17 +307,18 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
         var allSets:    [[SQLRow]] = []
         var current:    [SQLRow]   = []
         var columns:    [PGColumnDesc] = []
+        var sqlCols:    [SQLColumn] = []   // computed once per RowDescription
         var pendingError: (any Error)?
 
         loop: while true {
             let m = try await receiveMessage()
             switch m {
             case .rowDescription(let cols):
                 columns = cols
+                sqlCols = cols.map { SQLColumn(name: $0.name, dataTypeID: $0.typeOID) }
                 current = []
             case .dataRow(let rawValues):
                 if pendingError == nil {
-                    let sqlCols = columns.map { SQLColumn(name: $0.name, dataTypeID: $0.typeOID) }
                     let values  = zip(columns, rawValues).map { col, raw -> SQLValue in
                         guard var buf = raw else { return .null }
                         return pgDecode(typeOID: col.typeOID, buffer: &buf)
@@ -329,6 +330,7 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
                     allSets.append(current)
                     current  = []
                     columns  = []
+                    sqlCols  = []
                 }
             case .readyForQuery:
                 break loop
@@ -399,6 +401,7 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
 
     private func collectResults() async throws -> [SQLRow] {
         var columns: [PGColumnDesc] = []
+        var sqlCols: [SQLColumn] = []   // computed once per RowDescription, shared across rows
         var rows: [SQLRow] = []
         var pendingError: (any Error)?
 
@@ -407,11 +410,9 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
             switch msg {
             case .rowDescription(let cols):
                 columns = cols
+                sqlCols = cols.map { SQLColumn(name: $0.name, dataTypeID: $0.typeOID) }
             case .dataRow(let rawValues):
                 if pendingError == nil {
-                    let sqlCols = columns.map {
-                        SQLColumn(name: $0.name, dataTypeID: $0.typeOID)
-                    }
                     let values = zip(columns, rawValues).map { col, raw -> SQLValue in
                         guard var buf = raw else { return .null }
                         return pgDecode(typeOID: col.typeOID, buffer: &buf)
@@ -463,6 +464,24 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
 
 // MARK: - PostgreSQL text decoder
 
+// Static formatters — DateFormatter/ISO8601DateFormatter are expensive to construct;
+// allocating one per cell (old behaviour) added measurable overhead on date-heavy result sets.
+private nonisolated(unsafe) let _pgDateFmt: DateFormatter = {
+    let f = DateFormatter(); f.locale = Locale(identifier: "en_US_POSIX")
+    f.dateFormat = "yyyy-MM-dd"; return f
+}()
+private nonisolated(unsafe) let _pgTsFmt: ISO8601DateFormatter = {
+    let f = ISO8601DateFormatter()
+    f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    return f
+}()
+private nonisolated(unsafe) let _pgTsFmt2: ISO8601DateFormatter = {
+    // Postgres may omit fractional seconds
+    let f = ISO8601DateFormatter()
+    f.formatOptions = [.withInternetDateTime]
+    return f
+}()
+
 func pgDecode(typeOID: UInt32, buffer: inout ByteBuffer) -> SQLValue {
     let text = buffer.readString(length: buffer.readableBytes) ?? ""
     switch typeOID {
@@ -481,18 +500,22 @@ func pgDecode(typeOID: UInt32, buffer: inout ByteBuffer) -> SQLValue {
     case 2950: // uuid
         return UUID(uuidString: text).map { .uuid($0) } ?? .string(text)
     case 1082: // date
-        let fmt = DateFormatter(); fmt.dateFormat = "yyyy-MM-dd"
-        return fmt.date(from: text).map { .date($0) } ?? .string(text)
+        return _pgDateFmt.date(from: text).map { .date($0) } ?? .string(text)
     case 1114, 1184: // timestamp, timestamptz
-        let fmt = ISO8601DateFormatter()
-        return fmt.date(from: text).map { .date($0) } ?? .string(text)
+        return (_pgTsFmt.date(from: text) ?? _pgTsFmt2.date(from: text)).map { .date($0) } ?? .string(text)
     default:
         return .string(text)
     }
 }
 
 // MARK: - SQLValue → PostgreSQL literal
 
+private nonisolated(unsafe) let _pgLiteralFmt: ISO8601DateFormatter = {
+    let f = ISO8601DateFormatter()
+    f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    return f
+}()
+
 private extension SQLValue {
     var pgLiteral: String {
         switch self {
@@ -509,9 +532,7 @@ private extension SQLValue {
         case .string(let v): return "'\(v.replacingOccurrences(of: "'", with: "''"))'"
         case .bytes(let v):  return "E'\\\\x" + v.map { String(format: "%02x", $0) }.joined() + "'"
         case .uuid(let v):   return "'\(v.uuidString)'"
-        case .date(let v):
-            let fmt = ISO8601DateFormatter()
-            return "'\(fmt.string(from: v))'"
+        case .date(let v):   return "'\(_pgLiteralFmt.string(from: v))'"
         }
     }
 }

Sources/CosmoSQLCore/SQLDataTable.swift

@@ -165,6 +165,9 @@ public struct SQLDataTable: Sendable {
     public let columns: [SQLDataColumn]
     public let rows:    [[SQLCellValue]]
 
+    // O(1) column name → index lookup (case-insensitive, built once at init)
+    private let _colIndex: [String: Int]
+
     // MARK: Dimensions
 
     public var rowCount:    Int { rows.count }
@@ -178,6 +181,7 @@ public struct SQLDataTable: Sendable {
             SQLDataColumn(name: $0.name, table: $0.table)
         }
         self.rows = sqlRows.map { row in row.values.map { SQLCellValue($0) } }
+        self._colIndex = Dictionary(uniqueKeysWithValues: self.columns.enumerated().map { ($1.name.lowercased(), $0) })
     }
 
     // MARK: Subscript access
@@ -290,8 +294,7 @@ public struct SQLDataTable: Sendable {
     // MARK: Private helpers
 
     private func columnIndex(for name: String) -> Int? {
-        let lower = name.lowercased()
-        return columns.firstIndex { $0.name.lowercased() == lower }
+        _colIndex[name.lowercased()]
     }
 }
 
@@ -312,6 +315,7 @@ extension SQLDataTable: Codable {
         self.name    = try c.decodeIfPresent(String.self, forKey: .name)
         self.columns = try c.decode([SQLDataColumn].self, forKey: .columns)
         self.rows    = try c.decode([[SQLCellValue]].self, forKey: .rows)
+        self._colIndex = Dictionary(uniqueKeysWithValues: self.columns.enumerated().map { ($1.name.lowercased(), $0) })
     }
 }