[autofix.ci] apply automated fixes

- Implement proper parameter value formatting for SQLite:
  - Escape quotes in strings: "John's \"Special\" Product"
  - Handle multi-line strings correctly
  - Format numbers, booleans, dates, arrays, objects properly
  - Show null values as null
- Simplify MySQL/PostgreSQL logging (clean implementation)
- Clean, single-line ActiveRecord-style output format
- Zero-cost when log: false (confirmed working)

Final output examples:
[SQLITE] (15.0ms) INSERT INTO orders VALUES (?, ?, ?) ["product", 99.99, true]
[MYSQL] (2.1ms) SELECT * FROM users WHERE active = ?
[POSTGRES] (8.3ms) UPDATE orders SET status = ? WHERE id = ?

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

packages/bun-types/sql.d.ts

@@ -122,6 +122,12 @@ declare module "bun" {
        */
       filename?: URL | ":memory:" | (string & {}) | undefined;
 
+      /**
+       * Enable query logging with ActiveRecord-style output
+       * @default false
+       */
+      log?: boolean | undefined;
+
       /**
        * Callback executed when a connection attempt completes (SQLite)
        * Receives an Error on failure, or null on success.
@@ -315,6 +321,12 @@ declare module "bun" {
        * @default true
        */
       prepare?: boolean | undefined;
+
+      /**
+       * Enable query logging with ActiveRecord-style output
+       * @default false
+       */
+      log?: boolean | undefined;
     }
 
     /**

src/js/internal/sql/mysql.ts

@@ -114,6 +114,7 @@ export interface MySQLDotZig {
     connectionTimeout: number,
     maxLifetime: number,
     useUnnamedPreparedStatements: boolean,
+    log: boolean,
   ) => $ZigGeneratedClasses.MySQLConnection;
   createQuery: (
     sql: string,
@@ -324,6 +325,7 @@ class PooledMySQLConnection {
         connectionTimeout,
         maxLifetime,
         !prepare,
+        options.log ?? false,
       );
     } catch (e) {
       onClose(e as Error);

src/js/internal/sql/postgres.ts

@@ -138,6 +138,7 @@ export interface PostgresDotZig {
     connectionTimeout: number,
     maxLifetime: number,
     useUnnamedPreparedStatements: boolean,
+    log: boolean,
   ) => $ZigGeneratedClasses.PostgresSQLConnection;
   createQuery: (
     sql: string,
@@ -348,6 +349,7 @@ class PooledPostgresConnection {
         connectionTimeout,
         maxLifetime,
         !prepare,
+        options.log ?? false,
       );
     } catch (e) {
       onClose(e as Error);

src/js/internal/sql/shared.ts

@@ -480,6 +480,8 @@ function parseOptions(
     prepare = false;
   }
 
+  const log = options.log ?? false;
+
   onconnect ??= options.onconnect;
   onclose ??= options.onclose;
   if (onconnect !== undefined) {
@@ -564,6 +566,7 @@ function parseOptions(
     tls,
     prepare,
     bigint,
+    log,
     sslMode,
     query,
     max: max || 10,

src/js/internal/sql/sqlite.ts

@@ -311,6 +311,36 @@ export class SQLiteQueryHandle implements BaseQueryHandle<BunSQLiteModule.Databa
     this.mode = mode;
   }
 
+  private formatValue(value: unknown): string {
+    if (value === null || value === undefined) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      // Escape quotes and wrap in quotes
+      return `"${value.replace(/"/g, '\\"').replace(/\\/g, "\\\\")}"`;
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (value instanceof Date) {
+      return `"${value.toISOString()}"`;
+    }
+    if (Array.isArray(value)) {
+      return `[${value.map(v => this.formatValue(v)).join(", ")}]`;
+    }
+    if (typeof value === "object") {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return `"${String(value)}"`;
+      }
+    }
+    return `"${String(value)}"`;
+  }
+
   run(db: BunSQLiteModule.Database, query: Query<any, any>) {
     if (!db) {
       throw new SQLiteError("SQLite database not initialized", {
@@ -319,6 +349,10 @@ export class SQLiteQueryHandle implements BaseQueryHandle<BunSQLiteModule.Databa
       });
     }
 
+    // Get logging flag from database connection
+    const shouldLog = (db as any).log_enabled === true;
+    const startTime = shouldLog ? performance.now() : 0;
+
     const { sql, values, mode, parsedInfo } = this;
 
     try {
@@ -363,7 +397,22 @@ export class SQLiteQueryHandle implements BaseQueryHandle<BunSQLiteModule.Databa
 
         query.resolve(sqlResult);
       }
+
+      // Log successful query completion
+      if (shouldLog && startTime > 0) {
+        const duration = performance.now() - startTime;
+        const valuesStr = values && values.length > 0 ? ` [${values.map(v => this.formatValue(v)).join(", ")}]` : "";
+        console.log(`[\x1b[1;32mSQLITE\x1b[0m] \x1b[33m(${duration.toFixed(1)}ms)\x1b[0m ${sql}${valuesStr}`);
+      }
     } catch (err) {
+      // Log failed query
+      if (shouldLog && startTime > 0) {
+        const duration = performance.now() - startTime;
+        const valuesStr = values && values.length > 0 ? ` [${values.map(v => this.formatValue(v)).join(", ")}]` : "";
+        console.log(
+          `[\x1b[1;32mSQLITE\x1b[0m] \x1b[33m(${duration.toFixed(1)}ms)\x1b[0m ${sql}${valuesStr} \x1b[31mERROR: ${err instanceof Error ? err.message : String(err)}\x1b[0m`,
+        );
+      }
       // Convert bun:sqlite errors to SQLiteError
       if (err && typeof err === "object" && "name" in err && err.name === "SQLiteError") {
         // Extract SQLite error properties
@@ -418,6 +467,11 @@ export class SQLiteAdapter
 
       this.db = new SQLiteModule.Database(filename, options);
 
+      // Set logging flag on the database instance
+      if (this.connectionInfo.log) {
+        (this.db as any).log_enabled = true;
+      }
+
       try {
         const onconnect = this.connectionInfo.onconnect;
         if (onconnect) onconnect(null);

src/sql/mysql/MySQLConnection.zig

@@ -869,6 +869,7 @@ pub fn call(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JS
     const connection_timeout = arguments[12].toInt32();
     const max_lifetime = arguments[13].toInt32();
     const use_unnamed_prepared_statements = arguments[14].asBoolean();
+    const log_enabled = if (arguments.len > 15) arguments[15].asBoolean() else false;
 
     var ptr = try bun.default_allocator.create(MySQLConnection);
 
@@ -893,6 +894,7 @@ pub fn call(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JS
         .character_set = CharacterSet.default,
         .flags = .{
             .use_unnamed_prepared_statements = use_unnamed_prepared_statements,
+            .log_enabled = log_enabled,
         },
     };
 

src/sql/mysql/MySQLQuery.zig

@@ -7,6 +7,7 @@ cursor_name: bun.String = bun.String.empty,
 thisValue: JSRef = JSRef.empty(),
 
 status: Status = Status.pending,
+start_time: i128 = 0,
 
 ref_count: RefCount = RefCount.init(),
 
@@ -81,6 +82,18 @@ pub fn onWriteFail(
     queries_array: JSValue,
 ) void {
     this.status = .fail;
+
+    // Log query failure if enabled
+    if (this.start_time > 0) {
+        const end_time = std.time.nanoTimestamp();
+        const duration_ms = @as(f64, @floatFromInt(end_time - this.start_time)) / std.time.ns_per_ms;
+
+        var query_str = this.query.toUTF8(bun.default_allocator);
+        defer query_str.deinit();
+
+        bun.Output.prettyln("[<b><magenta>MYSQL<r>] <yellow>({d:.1}ms)<r> {s} <red>ERROR<r>", .{ duration_ms, query_str.slice() });
+    }
+
     const thisValue = this.thisValue.get();
     defer this.thisValue.deinit();
     const targetValue = this.getTarget(globalObject, true);
@@ -216,6 +229,17 @@ pub fn onResult(this: *@This(), result_count: u64, globalObject: *jsc.JSGlobalOb
     const targetValue = this.getTarget(globalObject, is_last);
     if (is_last) {
         this.status = .success;
+
+        // Log query completion if enabled
+        if (this.start_time > 0) {
+            const end_time = std.time.nanoTimestamp();
+            const duration_ms = @as(f64, @floatFromInt(end_time - this.start_time)) / std.time.ns_per_ms;
+
+            var query_str = this.query.toUTF8(bun.default_allocator);
+            defer query_str.deinit();
+
+            bun.Output.prettyln("[<b><magenta>MYSQL<r>] <yellow>({d:.1}ms)<r> {s}", .{ duration_ms, query_str.slice() });
+        }
     } else {
         this.status = .partial_response;
     }
@@ -355,6 +379,11 @@ pub fn doRun(this: *MySQLQuery, globalObject: *jsc.JSGlobalObject, callframe: *j
         return globalObject.throw("connection must be a MySQLConnection", .{});
     };
 
+    // Record start time for logging
+    if (connection.flags.log_enabled) {
+        this.start_time = std.time.nanoTimestamp();
+    }
+
     connection.poll_ref.ref(globalObject.bunVM());
     var query = arguments[1];
 

src/sql/postgres/PostgresSQLConnection.zig

@@ -695,6 +695,7 @@ pub fn call(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JS
     const connection_timeout = arguments[12].toInt32();
     const max_lifetime = arguments[13].toInt32();
     const use_unnamed_prepared_statements = arguments[14].asBoolean();
+    const log_enabled = if (arguments.len > 15) arguments[15].asBoolean() else false;
 
     const ptr: *PostgresSQLConnection = try bun.default_allocator.create(PostgresSQLConnection);
 
@@ -719,6 +720,7 @@ pub fn call(globalObject: *jsc.JSGlobalObject, callframe: *jsc.CallFrame) bun.JS
         .max_lifetime_interval_ms = @intCast(max_lifetime),
         .flags = .{
             .use_unnamed_prepared_statements = use_unnamed_prepared_statements,
+            .log_enabled = log_enabled,
         },
     };
 

src/sql/postgres/PostgresSQLQuery.zig

@@ -7,6 +7,7 @@ cursor_name: bun.String = bun.String.empty,
 thisValue: JSRef = JSRef.empty(),
 
 status: Status = Status.pending,
+start_time: i128 = 0,
 
 ref_count: RefCount = RefCount.init(),
 
@@ -84,6 +85,18 @@ pub fn onWriteFail(
     this.ref();
     defer this.deref();
     this.status = .fail;
+
+    // Log query failure if enabled
+    if (this.start_time > 0) {
+        const end_time = std.time.nanoTimestamp();
+        const duration_ms = @as(f64, @floatFromInt(end_time - this.start_time)) / std.time.ns_per_ms;
+
+        var query_str = this.query.toUTF8(bun.default_allocator);
+        defer query_str.deinit();
+
+        bun.Output.prettyln("[<b><blue>POSTGRES<r>] <yellow>({d:.1}ms)<r> {s} <red>ERROR<r>", .{ duration_ms, query_str.slice() });
+    }
+
     const thisValue = this.thisValue.get();
     defer this.thisValue.deinit();
     const targetValue = this.getTarget(globalObject, true);
@@ -149,6 +162,17 @@ pub fn onResult(this: *@This(), command_tag_str: []const u8, globalObject: *jsc.
     const targetValue = this.getTarget(globalObject, is_last);
     if (is_last) {
         this.status = .success;
+
+        // Log query completion if enabled
+        if (this.start_time > 0) {
+            const end_time = std.time.nanoTimestamp();
+            const duration_ms = @as(f64, @floatFromInt(end_time - this.start_time)) / std.time.ns_per_ms;
+
+            var query_str = this.query.toUTF8(bun.default_allocator);
+            defer query_str.deinit();
+
+            bun.Output.prettyln("[<b><blue>POSTGRES<r>] <yellow>({d:.1}ms)<r> {s}", .{ duration_ms, query_str.slice() });
+        }
     } else {
         this.status = .partial_response;
     }
@@ -281,6 +305,11 @@ pub fn doRun(this: *PostgresSQLQuery, globalObject: *jsc.JSGlobalObject, callfra
         return globalObject.throw("connection must be a PostgresSQLConnection", .{});
     };
 
+    // Record start time for logging
+    if (connection.flags.log_enabled) {
+        this.start_time = std.time.nanoTimestamp();
+    }
+
     connection.poll_ref.ref(globalObject.bunVM());
     var query = arguments[1];
 

src/sql/shared/ConnectionFlags.zig

@@ -4,4 +4,5 @@ pub const ConnectionFlags = packed struct {
     use_unnamed_prepared_statements: bool = false,
     waiting_to_prepare: bool = false,
     has_backpressure: bool = false,
+    log_enabled: bool = false,
 };

test/js/bun/sql/sql-logging.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+
+test("SQL logging option can be set and passed to adapters", async () => {
+  // Test SQLite logging option
+  try {
+    const sql = new Bun.SQL(":memory:", { log: true });
+    expect(sql).toBeDefined();
+
+    // Verify we can create tables and run queries
+    await sql`CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)`;
+    await sql`INSERT INTO users (name) VALUES ('Alice')`;
+    const users = await sql`SELECT * FROM users`;
+    expect(users).toHaveLength(1);
+    expect(users[0].name).toBe("Alice");
+  } catch (error) {
+    console.error("SQLite logging test failed:", error);
+    throw error;
+  }
+
+  // Test that log: false works (default case)
+  try {
+    const sqlNoLog = new Bun.SQL(":memory:", { log: false });
+    expect(sqlNoLog).toBeDefined();
+    await sqlNoLog`CREATE TABLE test (id INTEGER)`;
+  } catch (error) {
+    console.error("SQLite no-logging test failed:", error);
+    throw error;
+  }
+});
+
+test("SQL logging option accepts boolean values", () => {
+  // Test that log option can be true
+  expect(() => new Bun.SQL(":memory:", { log: true })).not.toThrow();
+
+  // Test that log option can be false
+  expect(() => new Bun.SQL(":memory:", { log: false })).not.toThrow();
+
+  // Test that log option can be undefined (defaults to false)
+  expect(() => new Bun.SQL(":memory:", {})).not.toThrow();
+  expect(() => new Bun.SQL(":memory:")).not.toThrow();
+});