Port C# @name parameter fixes to Swift MySQL and Postgres drivers

MySQL (MySQLConnection.swift):
- Add query(_:params:[String:SQLValue]) overload with @name placeholder support
- Add execute(_:params:[String:SQLValue]) overload with @name placeholder support
- Add renderQueryNamed: scans SQL for @Identifier, inlines escaped literals
  (text protocol — values are safely escaped via mysqlLiteral before sending)

MySQL (MySQLDecoder.swift):
- Fix DATETIME/TIMESTAMP parsing to handle fractional seconds (microseconds)
  e.g. '2026-03-03 23:07:01.063905' — adds _mysqlDateTimeFracFmt fallback
  Equivalent to C# ParseBinaryDateTime which already handled fractional precision

Postgres (PostgresConnection.swift):
- Add query(_:params:[String:SQLValue]) overload with @name placeholder support
- Add execute(_:params:[String:SQLValue]) overload with @name placeholder support
- Add renderQueryNamed: scans SQL for @Identifier, inlines escaped literals
  (simple query protocol — values are safely escaped via pgLiteral before sending)

Note: Swift drivers use text/simple-query protocol (not prepared statements),
so C# bugs 1-3 (null handler, CLIENT_DEPRECATE_EOF, binary protocol rows) do
not apply. The @name param translation mirrors C#'s TranslateParams fix but
works at a higher level: inline literal substitution rather than placeholder
rewriting for a wire protocol.

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

Author: vkuttyp

Sources/CosmoMySQL/MySQLConnection.swift

@@ -430,6 +430,75 @@ public final class MySQLConnection: SQLDatabase, @unchecked Sendable {
         try await channel.close().get()
     }
 
+    // MARK: - Named parameter API (@name style)
+
+    /// Execute a query with named parameters.
+    ///
+    /// Use `@name` placeholders in SQL; pass values as a dictionary.
+    /// Values are inlined as escaped literals (text protocol), so this is safe for
+    /// all backends without prepared-statement support.
+    ///
+    /// Example:
+    /// ```swift
+    /// let rows = try await conn.query(
+    ///     "SELECT * FROM credentials WHERE accesskey = @ak",
+    ///     params: ["ak": .string("mykey")])
+    /// ```
+    public func query(_ sql: String, params: [String: SQLValue]) async throws -> [SQLRow] {
+        guard !isClosed else { throw SQLError.connectionClosed }
+        let rendered = renderQueryNamed(sql, params: params)
+        logger.debug("MySQL query: \(rendered)")
+        try await sendQuery(rendered)
+        return try await readResultSet()
+    }
+
+    /// Execute a DML statement with named parameters and return affected row count.
+    public func execute(_ sql: String, params: [String: SQLValue]) async throws -> Int {
+        guard !isClosed else { throw SQLError.connectionClosed }
+        let rendered = renderQueryNamed(sql, params: params)
+        logger.debug("MySQL execute: \(rendered)")
+        try await sendQuery(rendered)
+        var packet = try await receivePacket()
+        let resp = try MySQLResponse.decode(packet: &packet, capabilities: capabilities)
+        switch resp {
+        case .ok(let affected, _, _, _):
+            return Int(affected)
+        case .err(let code, _, let message):
+            throw SQLError.serverError(code: Int(code), message: message)
+        default:
+            return 0
+        }
+    }
+
+    /// Translates `@name` placeholders to inlined MySQL literals.
+    /// Scans the SQL string, replacing each `@identifier` with the escaped literal
+    /// for the matching key in `params`. Unknown names are left unchanged.
+    private func renderQueryNamed(_ sql: String, params: [String: SQLValue]) -> String {
+        var result = ""
+        var i = sql.startIndex
+        while i < sql.endIndex {
+            guard sql[i] == "@" else { result.append(sql[i]); i = sql.index(after: i); continue }
+            let afterAt = sql.index(after: i)
+            // Must be followed by a letter or underscore to be an identifier
+            guard afterAt < sql.endIndex, sql[afterAt].isLetter || sql[afterAt] == "_" else {
+                result.append(sql[i]); i = sql.index(after: i); continue
+            }
+            // Read the full identifier
+            var end = afterAt
+            while end < sql.endIndex && (sql[end].isLetter || sql[end].isNumber || sql[end] == "_") {
+                end = sql.index(after: end)
+            }
+            let name = String(sql[afterAt..<end])
+            if let value = params[name] {
+                result += value.mysqlLiteral
+            } else {
+                result += "@"; result += name   // leave unknown names unchanged
+            }
+            i = end
+        }
+        return result
+    }
+
     // MARK: - COM_QUERY
 
     private func sendQuery(_ sql: String) async throws {

Sources/CosmoMySQL/Protocol/MySQLDecoder.swift

@@ -193,6 +193,11 @@ private let _mysqlDateTimeFmt: DateFormatter = {
     let f = DateFormatter(); f.locale = Locale(identifier: "en_US_POSIX")
     f.dateFormat = "yyyy-MM-dd HH:mm:ss"; return f
 }()
+// MySQL can return microseconds: "2026-03-03 23:07:01.063905"
+private let _mysqlDateTimeFracFmt: DateFormatter = {
+    let f = DateFormatter(); f.locale = Locale(identifier: "en_US_POSIX")
+    f.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSSSS"; return f
+}()
 
 func mysqlDecode(columnType: UInt8, isUnsigned: Bool, text: String?) -> SQLValue {
     guard let text = text else { return .null }
@@ -219,7 +224,9 @@ func mysqlDecode(columnType: UInt8, isUnsigned: Bool, text: String?) -> SQLValue
     case 0x0A:  // DATE
         return _mysqlDateFmt.date(from: text).map { .date($0) } ?? .string(text)
     case 0x0B, 0x0C, 0x07: // TIME, DATETIME, TIMESTAMP
-        return _mysqlDateTimeFmt.date(from: text).map { .date($0) } ?? .string(text)
+        // Try without fractional seconds first (most common), then with microseconds
+        let date = _mysqlDateTimeFmt.date(from: text) ?? _mysqlDateTimeFracFmt.date(from: text)
+        return date.map { .date($0) } ?? .string(text)
     default:
         return .string(text)
     }

Sources/CosmoPostgres/PostgresConnection.swift

@@ -517,6 +517,83 @@ public final class PostgresConnection: SQLDatabase, @unchecked Sendable {
         try await channel.close().get()
     }
 
+    // MARK: - Named parameter API (@name style)
+
+    /// Execute a query with named parameters.
+    ///
+    /// Use `@name` placeholders in SQL; pass values as a dictionary.
+    /// Values are inlined as escaped literals (simple query protocol).
+    ///
+    /// Example:
+    /// ```swift
+    /// let rows = try await conn.query(
+    ///     "SELECT * FROM s3.credentials WHERE accesskey = @ak",
+    ///     params: ["ak": .string("mykey")])
+    /// ```
+    public func query(_ sql: String, params: [String: SQLValue]) async throws -> [SQLRow] {
+        guard !isClosed else { throw SQLError.connectionClosed }
+        let rendered = renderQueryNamed(sql, params: params)
+        logger.debug("PostgreSQL query: \(rendered)")
+        let msg = PGFrontend.query(rendered, allocator: channel.allocator)
+        send(msg)
+        return try await collectResults()
+    }
+
+    /// Execute a DML statement with named parameters and return affected row count.
+    public func execute(_ sql: String, params: [String: SQLValue]) async throws -> Int {
+        guard !isClosed else { throw SQLError.connectionClosed }
+        let rendered = renderQueryNamed(sql, params: params)
+        logger.debug("PostgreSQL execute: \(rendered)")
+        let msg = PGFrontend.query(rendered, allocator: channel.allocator)
+        send(msg)
+        var rowsAffected = 0
+        var pendingError: (any Error)?
+        loop: while true {
+            let m = try await receiveMessage()
+            switch m {
+            case .commandComplete(let tag):
+                rowsAffected = tag.rowsAffected
+            case .readyForQuery:
+                break loop
+            case .error(_, _, let message):
+                pendingError = SQLError.serverError(code: 0, message: message)
+            case .notice(let msg):
+                onNotice?(msg)
+            default:
+                break
+            }
+        }
+        if let err = pendingError { throw err }
+        return rowsAffected
+    }
+
+    /// Translates `@name` placeholders to inlined PostgreSQL literals.
+    /// Scans the SQL string, replacing each `@identifier` with the escaped literal
+    /// for the matching key in `params`. Unknown names are left unchanged.
+    private func renderQueryNamed(_ sql: String, params: [String: SQLValue]) -> String {
+        var result = ""
+        var i = sql.startIndex
+        while i < sql.endIndex {
+            guard sql[i] == "@" else { result.append(sql[i]); i = sql.index(after: i); continue }
+            let afterAt = sql.index(after: i)
+            guard afterAt < sql.endIndex, sql[afterAt].isLetter || sql[afterAt] == "_" else {
+                result.append(sql[i]); i = sql.index(after: i); continue
+            }
+            var end = afterAt
+            while end < sql.endIndex && (sql[end].isLetter || sql[end].isNumber || sql[end] == "_") {
+                end = sql.index(after: end)
+            }
+            let name = String(sql[afterAt..<end])
+            if let value = params[name] {
+                result += value.pgLiteral
+            } else {
+                result += "@"; result += name
+            }
+            i = end
+        }
+        return result
+    }
+
     // MARK: - Result collection
 
     private func collectResults() async throws -> [SQLRow] {