feat(sql) add PostgreSQL COPY support (excluding CopyBoth)

.gitignore

@@ -20,6 +20,7 @@
 .vscode/clang*
 .vscode/cpp*
 .zig-cache
+.ccls-cache
 .bake-debug
 *.a
 *.bc

.zed/settings.json

@@ -0,0 +1,9 @@
+{
+  "lsp": {
+    "zls": {
+      "settings": {
+        "build_on_save_args": ["-Dgenerated-code=./build/debug/codegen", "--watch", "-fincremental"],
+      },
+    },
+  },
+}

packages/bun-types/sql.d.ts

@@ -10,6 +10,72 @@ declare module "bun" {
      * Releases the client back to the connection pool
      */
     release(): void;
+
+    /**
+     * Register callback when server replies with CopyInResponse/CopyOutResponse
+     */
+    onCopyStart(handler: () => void): void;
+
+    /**
+     * Send COPY data chunk (for COPY FROM STDIN)
+     */
+    copySendData(data: string | Uint8Array): void;
+
+    /**
+     * Signal end of COPY FROM STDIN operation
+     */
+    copyDone(): void;
+
+    /**
+     * Abort COPY operation with optional error message
+     */
+    copyFail(message?: string): void;
+
+    /**
+     * Enable or disable streaming mode for COPY TO
+     * When enabled, data is not accumulated in memory and chunks are emitted via onCopyChunk
+     */
+    setCopyStreamingMode(enable: boolean): void;
+
+    /**
+     * Set COPY operation timeout in milliseconds (0 to disable)
+     */
+    setCopyTimeout(ms: number): void;
+
+    /**
+     * Set maximum buffer size for COPY operations in bytes
+     */
+    setMaxCopyBufferSize(bytes: number): void;
+
+    /**
+     * Register callback for streaming COPY TO data chunks
+     *
+     * @returns true if the handler was registered (adapter supports streaming), otherwise false.
+     */
+    onCopyChunk(handler: (chunk: string | ArrayBuffer | Uint8Array) => void): boolean;
+
+    /**
+     * Register callback when COPY TO completes
+     *
+     * @returns true if the handler was registered (adapter supports streaming), otherwise false.
+     */
+    onCopyEnd(handler: () => void): boolean;
+
+    /**
+     * Get current COPY operation defaults
+     */
+    getCopyDefaults(): {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    };
+
+    /**
+     * Set COPY operation defaults
+     */
+    setCopyDefaults(defaults: {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    }): this;
   }
 
   type ArrayType =
@@ -18,7 +84,6 @@ declare module "bun" {
     | "CHAR"
     | "NAME"
     | "TEXT"
-    | "CHAR"
     | "VARCHAR"
     | "SMALLINT"
     | "INT2VECTOR"
@@ -60,6 +125,40 @@ declare module "bun" {
     | "PG_DATABASE"
     | (string & {});
 
+  /**
+   * PostgreSQL COPY binary format base types
+   */
+  type CopyBinaryBaseType =
+    | "bool"
+    | "int2"
+    | "int4"
+    | "int8"
+    | "float4"
+    | "float8"
+    | "text"
+    | "varchar"
+    | "bpchar"
+    | "bytea"
+    | "date"
+    | "time"
+    | "timestamp"
+    | "timestamptz"
+    | "uuid"
+    | "json"
+    | "jsonb"
+    | "numeric"
+    | "interval";
+
+  /**
+   * PostgreSQL COPY binary format array types
+   */
+  type CopyBinaryArrayType = `${CopyBinaryBaseType}[]`;
+
+  /**
+   * PostgreSQL COPY binary format type tokens
+   */
+  type CopyBinaryType = CopyBinaryBaseType | CopyBinaryArrayType;
+
   /**
    * Represents a SQL array parameter
    */
@@ -101,6 +200,48 @@ declare module "bun" {
       constructor(message: string);
     }
 
+    /**
+     * COPY FROM STDIN options (PostgreSQL COPY protocol)
+     */
+    type CopyFromOptions = {
+      format?: "text" | "csv" | "binary";
+      delimiter?: string;
+      null?: string;
+      sanitizeNUL?: boolean;
+      replaceInvalid?: string;
+      signal?: AbortSignal;
+      onProgress?: (info: { bytesSent: number; chunksSent: number }) => void;
+      batchSize?: number;
+      /**
+       * When format is "binary" and passing row arrays, provide per-column type tokens
+       * (e.g. "int4","text","uuid","int4[]")
+       */
+      binaryTypes?: readonly CopyBinaryType[];
+      /** Maximum number of bytes to send per chunk (defaults to 256 KiB) */
+      maxChunkSize?: number;
+      /** Maximum total number of bytes to send (0 = unlimited) */
+      maxBytes?: number;
+      /** COPY operation timeout in milliseconds (0 = no timeout) */
+      timeout?: number;
+    };
+
+    /**
+     * COPY TO STDOUT options (PostgreSQL COPY protocol)
+     */
+    type CopyToOptions = {
+      table: string;
+      columns?: string[];
+      format?: "text" | "csv" | "binary";
+      signal?: AbortSignal;
+      onProgress?: (info: { bytesReceived: number; chunksReceived: number }) => void;
+      /** Maximum total number of bytes to receive (0 = unlimited) */
+      maxBytes?: number;
+      /** Enable streaming mode to avoid buffering (defaults to true) */
+      stream?: boolean;
+      /** COPY operation timeout in milliseconds (0 = no timeout) */
+      timeout?: number;
+    };
+
     class PostgresError extends SQLError {
       public readonly code: string;
       public readonly errno?: string | undefined;
@@ -537,6 +678,53 @@ declare module "bun" {
      * ```
      */
     <T>(value: T): SQL.Helper<T>;
+
+    /** COPY FROM STDIN - bulk import helper (PostgreSQL COPY protocol) */
+    copyFrom(
+      table: string,
+      columns: string[],
+      data:
+        | string
+        | unknown[]
+        | Iterable<unknown[]>
+        | AsyncIterable<unknown[]>
+        | AsyncIterable<string | Uint8Array | ArrayBuffer>
+        | (() => Iterable<unknown[]>),
+      options?: SQL.CopyFromOptions,
+    ): Promise<{ command: string | null; count: number | null }>;
+
+    /** COPY TO STDOUT - streaming export helper (PostgreSQL COPY protocol) */
+    copyTo(queryOrOptions: string | SQL.CopyToOptions): AsyncIterable<string | ArrayBuffer>;
+
+    /** COPY TO STDOUT piping helper - pipe stream directly to a sink */
+    copyToPipeTo(
+      queryOrOptions: string | SQL.CopyToOptions,
+      writable:
+        | WritableStream<Uint8Array | string>
+        | {
+            write: (chunk: string | ArrayBuffer | Uint8Array) => unknown | Promise<unknown>;
+            close?: () => unknown | Promise<unknown>;
+            end?: () => unknown | Promise<unknown>;
+          },
+    ): Promise<void>;
+
+    /**
+     * Get current COPY operation defaults
+     */
+    getCopyDefaults(): {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    };
+
+    /**
+     * Set COPY operation defaults
+     *
+     * Returns the SQL instance for chaining.
+     */
+    setCopyDefaults(defaults: {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    }): this;
   }
 
   /**
@@ -866,6 +1054,53 @@ declare module "bun" {
      * const result = await sql.file("query.sql", [1, 2, 3]);
      */
     file<T = any>(filename: string, values?: any[]): SQL.Query<T>;
+
+    /** COPY FROM STDIN - bulk import helper (PostgreSQL COPY protocol) */
+    copyFrom(
+      table: string,
+      columns: string[],
+      data:
+        | string
+        | unknown[]
+        | Iterable<unknown[]>
+        | AsyncIterable<unknown[]>
+        | AsyncIterable<string | Uint8Array | ArrayBuffer>
+        | (() => Iterable<unknown[]>),
+      options?: SQL.CopyFromOptions,
+    ): Promise<{ command: string | null; count: number | null }>;
+
+    /** COPY TO STDOUT - streaming export helper (PostgreSQL COPY protocol) */
+    copyTo(queryOrOptions: string | SQL.CopyToOptions): AsyncIterable<string | ArrayBuffer>;
+
+    /** COPY TO STDOUT piping helper - pipe stream directly to a sink */
+    copyToPipeTo(
+      queryOrOptions: string | SQL.CopyToOptions,
+      writable:
+        | WritableStream<Uint8Array | string>
+        | {
+            write: (chunk: string | ArrayBuffer | Uint8Array) => unknown | Promise<unknown>;
+            close?: () => unknown | Promise<unknown>;
+            end?: () => unknown | Promise<unknown>;
+          },
+    ): Promise<void>;
+
+    /**
+     * Get current COPY operation defaults
+     */
+    getCopyDefaults(): {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    };
+
+    /**
+     * Set COPY operation defaults
+     *
+     * Returns the SQL instance for chaining.
+     */
+    setCopyDefaults(defaults: {
+      from?: { maxChunkSize?: number; maxBytes?: number; timeout?: number };
+      to?: { stream?: boolean; maxBytes?: number; timeout?: number };
+    }): this;
   }
 
   /**

src/bun.js/api/sql.classes.ts

@@ -3,6 +3,54 @@ import { ClassDefinition, define } from "../../codegen/class-definitions";
 const types = ["PostgresSQL", "MySQL"];
 const classes: ClassDefinition[] = [];
 for (const type of types) {
+  const proto: any = {
+    close: {
+      fn: "doClose",
+    },
+    connected: {
+      getter: "getConnected",
+    },
+    ref: {
+      fn: "doRef",
+    },
+    unref: {
+      fn: "doUnref",
+    },
+    flush: {
+      fn: "doFlush",
+    },
+    queries: {
+      getter: "getQueries",
+      this: true,
+    },
+    onconnect: {
+      getter: "getOnConnect",
+      setter: "setOnConnect",
+      this: true,
+    },
+    onclose: {
+      getter: "getOnClose",
+      setter: "setOnClose",
+      this: true,
+    },
+  };
+
+  // Add COPY methods only for PostgreSQL
+  if (type === "PostgresSQL") {
+    proto.sendCopyData = {
+      fn: "sendCopyData",
+      length: 1,
+    };
+    proto.sendCopyDone = {
+      fn: "sendCopyDone",
+      length: 0,
+    };
+    proto.sendCopyFail = {
+      fn: "sendCopyFail",
+      length: 1,
+    };
+  }
+
   classes.push(
     define({
       name: `${type}Connection`,
@@ -19,37 +67,7 @@ for (const type of types) {
         //   },
       },
       JSType: "0b11101110",
-      proto: {
-        close: {
-          fn: "doClose",
-        },
-        connected: {
-          getter: "getConnected",
-        },
-        ref: {
-          fn: "doRef",
-        },
-        unref: {
-          fn: "doUnref",
-        },
-        flush: {
-          fn: "doFlush",
-        },
-        queries: {
-          getter: "getQueries",
-          this: true,
-        },
-        onconnect: {
-          getter: "getOnConnect",
-          setter: "setOnConnect",
-          this: true,
-        },
-        onclose: {
-          getter: "getOnClose",
-          setter: "setOnClose",
-          this: true,
-        },
-      },
+      proto,
       values: ["onconnect", "onclose", "queries"],
     }),
   );