@rip-lang/db 0.10.0 → 1.0.1

package/lib/duckdb.mjs

@@ -1,31 +1,49 @@
 /**
- * DuckDB bindings for Bun using Zig FFI
+ * DuckDB High-Performance Zig Bindings
  *
- * Clean, type-safe wrapper with full type support.
+ * Minimal JavaScript wrapper for the Zig implementation.
+ * The Zig code handles all binary serialization directly - no JS overhead!
+ *
+ * Usage:
+ *   import { open, queryBinary, tokenize } from './duckdb.mjs';
+ *
+ *   const db = open(':memory:');
+ *   const conn = db.connect();
+ *
+ *   // Returns binary ArrayBuffer - ready for HTTP response!
+ *   const result = queryBinary(conn.handle, 'SELECT 42', 10000);
+ *
+ *   // Returns binary ArrayBuffer for tokenize endpoint
+ *   const tokens = tokenize('SELECT * FROM users');
  */
 
-import { dlopen, ptr, CString } from 'bun:ffi';
+import { dlopen, ptr } from 'bun:ffi';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { platform, arch } from 'process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Map Node.js arch names
+// Map platform/arch to library path
 const archMap = { 'arm64': 'arm64', 'x64': 'x64', 'x86_64': 'x64' };
 const target = `${platform}-${archMap[arch] || arch}`;
-
-// Load the platform-specific native module
 const libPath = join(__dirname, `${target}/duckdb.node`);
 
-const duck = dlopen(libPath, {
-  // Database operations (usize = pointer-sized integer)
+// Load the Zig library
+const lib = dlopen(libPath, {
+  // Database lifecycle
   duck_open: { args: ['ptr'], returns: 'usize' },
   duck_close: { args: ['usize'], returns: 'void' },
   duck_connect: { args: ['usize'], returns: 'usize' },
   duck_disconnect: { args: ['usize'], returns: 'void' },
 
-  // Query operations
+  // Binary serialization (for DuckDB UI protocol)
+  duck_query_binary: { args: ['usize', 'ptr', 'ptr', 'usize', 'u64'], returns: 'usize' },
+  duck_tokenize: { args: ['ptr', 'usize', 'ptr', 'usize'], returns: 'usize' },
+  duck_empty_result: { args: ['ptr', 'usize'], returns: 'usize' },
+  duck_error_result: { args: ['ptr', 'ptr', 'usize'], returns: 'usize' },
+
+  // Basic query API (for JSON endpoints)
   duck_query: { args: ['usize', 'ptr'], returns: 'usize' },
   duck_free_result: { args: ['usize'], returns: 'void' },
   duck_result_error: { args: ['usize'], returns: 'ptr' },
@@ -33,380 +51,275 @@ const duck = dlopen(libPath, {
   duck_column_count: { args: ['usize'], returns: 'u64' },
   duck_column_name: { args: ['usize', 'u64'], returns: 'ptr' },
   duck_column_type: { args: ['usize', 'u64'], returns: 'u32' },
-
-  // Value extraction
   duck_value_is_null: { args: ['usize', 'u64', 'u64'], returns: 'bool' },
-  duck_value_bool: { args: ['usize', 'u64', 'u64'], returns: 'bool' },
-  duck_value_i8: { args: ['usize', 'u64', 'u64'], returns: 'i8' },
-  duck_value_i16: { args: ['usize', 'u64', 'u64'], returns: 'i16' },
-  duck_value_i32: { args: ['usize', 'u64', 'u64'], returns: 'i32' },
-  duck_value_i64: { args: ['usize', 'u64', 'u64'], returns: 'i64' },
-  duck_value_u8: { args: ['usize', 'u64', 'u64'], returns: 'u8' },
-  duck_value_u16: { args: ['usize', 'u64', 'u64'], returns: 'u16' },
-  duck_value_u32: { args: ['usize', 'u64', 'u64'], returns: 'u32' },
-  duck_value_u64: { args: ['usize', 'u64', 'u64'], returns: 'u64' },
-  duck_value_f32: { args: ['usize', 'u64', 'u64'], returns: 'f32' },
-  duck_value_f64: { args: ['usize', 'u64', 'u64'], returns: 'f64' },
-  duck_value_string_internal: { args: ['usize', 'u64', 'u64'], returns: 'ptr' },
-  duck_value_date_days: { args: ['usize', 'u64', 'u64'], returns: 'i32' },
-  duck_value_time_micros: { args: ['usize', 'u64', 'u64'], returns: 'i64' },
-  duck_value_timestamp_micros: { args: ['usize', 'u64', 'u64'], returns: 'i64' },
-
-  // Prepared statements
-  duck_prepare: { args: ['usize', 'ptr'], returns: 'usize' },
-  duck_prepare_error: { args: ['usize'], returns: 'ptr' },
-  duck_free_prepare: { args: ['usize'], returns: 'void' },
-  duck_nparams: { args: ['usize'], returns: 'u64' },
-  duck_param_type: { args: ['usize', 'u64'], returns: 'u32' },
-  duck_execute_prepared: { args: ['usize'], returns: 'usize' },
-
-  // Parameter binding
-  duck_bind_null: { args: ['usize', 'u64'], returns: 'bool' },
-  duck_bind_bool: { args: ['usize', 'u64', 'bool'], returns: 'bool' },
-  duck_bind_i8: { args: ['usize', 'u64', 'i8'], returns: 'bool' },
-  duck_bind_i16: { args: ['usize', 'u64', 'i16'], returns: 'bool' },
-  duck_bind_i32: { args: ['usize', 'u64', 'i32'], returns: 'bool' },
-  duck_bind_i64: { args: ['usize', 'u64', 'i64'], returns: 'bool' },
-  duck_bind_u8: { args: ['usize', 'u64', 'u8'], returns: 'bool' },
-  duck_bind_u16: { args: ['usize', 'u64', 'u16'], returns: 'bool' },
-  duck_bind_u32: { args: ['usize', 'u64', 'u32'], returns: 'bool' },
-  duck_bind_u64: { args: ['usize', 'u64', 'u64'], returns: 'bool' },
-  duck_bind_f32: { args: ['usize', 'u64', 'f32'], returns: 'bool' },
-  duck_bind_f64: { args: ['usize', 'u64', 'f64'], returns: 'bool' },
-  duck_bind_string: { args: ['usize', 'u64', 'ptr', 'u64'], returns: 'bool' },
-  duck_bind_blob: { args: ['usize', 'u64', 'ptr', 'u64'], returns: 'bool' },
-  duck_bind_timestamp: { args: ['usize', 'u64', 'i64'], returns: 'bool' },
-  duck_bind_date: { args: ['usize', 'u64', 'i32'], returns: 'bool' },
-  duck_bind_time: { args: ['usize', 'u64', 'i64'], returns: 'bool' },
-
-  // Utility
+  duck_value_varchar: { args: ['usize', 'u64', 'u64'], returns: 'ptr' },
+  duck_value_int64: { args: ['usize', 'u64', 'u64'], returns: 'i64' },
+  duck_value_double: { args: ['usize', 'u64', 'u64'], returns: 'f64' },
+  duck_value_boolean: { args: ['usize', 'u64', 'u64'], returns: 'bool' },
   duck_free: { args: ['usize'], returns: 'void' },
 }).symbols;
 
-// Note: Don't use .native versions as they convert BigInts to Numbers,
-// which can cause precision loss for pointer values on 64-bit systems.
-
-const utf8 = new TextEncoder();
-
-// DuckDB type enum
-const Type = {
-  INVALID: 0,
-  BOOLEAN: 1,
-  TINYINT: 2,
-  SMALLINT: 3,
-  INTEGER: 4,
-  BIGINT: 5,
-  UTINYINT: 6,
-  USMALLINT: 7,
-  UINTEGER: 8,
-  UBIGINT: 9,
-  FLOAT: 10,
-  DOUBLE: 11,
-  TIMESTAMP: 12,
-  DATE: 13,
-  TIME: 14,
-  INTERVAL: 15,
-  HUGEINT: 16,
-  VARCHAR: 17,
-  BLOB: 18,
-  DECIMAL: 19,
-  TIMESTAMP_S: 20,
-  TIMESTAMP_MS: 21,
-  TIMESTAMP_NS: 22,
-  ENUM: 23,
-  LIST: 24,
-  STRUCT: 25,
-  MAP: 26,
-  UUID: 27,
-  JSON: 28,
-};
+import { CString } from 'bun:ffi';
 
-// Value extractors by type
-const extractors = {
-  [Type.BOOLEAN]: (r, c, row) => duck.duck_value_bool(r, c, row),
-  [Type.TINYINT]: (r, c, row) => duck.duck_value_i8(r, c, row),
-  [Type.SMALLINT]: (r, c, row) => duck.duck_value_i16(r, c, row),
-  [Type.INTEGER]: (r, c, row) => duck.duck_value_i32(r, c, row),
-  [Type.BIGINT]: (r, c, row) => Number(duck.duck_value_i64(r, c, row)),  // Convert to Number for JSON compatibility
-  [Type.UTINYINT]: (r, c, row) => duck.duck_value_u8(r, c, row),
-  [Type.USMALLINT]: (r, c, row) => duck.duck_value_u16(r, c, row),
-  [Type.UINTEGER]: (r, c, row) => duck.duck_value_u32(r, c, row),
-  [Type.UBIGINT]: (r, c, row) => Number(duck.duck_value_u64(r, c, row)),  // Convert to Number for JSON compatibility
-  [Type.FLOAT]: (r, c, row) => duck.duck_value_f32(r, c, row),
-  [Type.DOUBLE]: (r, c, row) => duck.duck_value_f64(r, c, row),
-  [Type.DECIMAL]: (r, c, row) => duck.duck_value_f64(r, c, row),  // Treat as double
-  [Type.VARCHAR]: (r, c, row) => new CString(duck.duck_value_string_internal(r, c, row)).toString(),
-  [Type.JSON]: (r, c, row) => new CString(duck.duck_value_string_internal(r, c, row)).toString(),
-  [Type.UUID]: (r, c, row) => new CString(duck.duck_value_string_internal(r, c, row)).toString(),
-  [Type.DATE]: (r, c, row) => duck.duck_value_date_days(r, c, row) * 86400000, // ms since epoch
-  [Type.TIME]: (r, c, row) => Number(duck.duck_value_time_micros(r, c, row)) / 1000,   // ms
-  [Type.TIMESTAMP]: (r, c, row) => Number(duck.duck_value_timestamp_micros(r, c, row)) / 1000,
-  [Type.TIMESTAMP_S]: (r, c, row) => Number(duck.duck_value_timestamp_micros(r, c, row)) / 1000,
-  [Type.TIMESTAMP_MS]: (r, c, row) => Number(duck.duck_value_timestamp_micros(r, c, row)) / 1000,
-  [Type.TIMESTAMP_NS]: (r, c, row) => Number(duck.duck_value_timestamp_micros(r, c, row)) / 1000,
-  [Type.HUGEINT]: (r, c, row) => Number(duck.duck_value_i64(r, c, row)),  // Simplified, Number for JSON
-};
+// Pre-allocated buffer for query results (16MB default)
+const DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024;
+let sharedBuffer = new Uint8Array(DEFAULT_BUFFER_SIZE);
 
-// Parameter binders by type
-const binders = {
-  [Type.BOOLEAN]: (stmt, idx, val) => duck.duck_bind_bool(stmt, idx, val),
-  [Type.TINYINT]: (stmt, idx, val) => duck.duck_bind_i8(stmt, idx, val | 0),
-  [Type.SMALLINT]: (stmt, idx, val) => duck.duck_bind_i16(stmt, idx, val | 0),
-  [Type.INTEGER]: (stmt, idx, val) => duck.duck_bind_i32(stmt, idx, val | 0),
-  [Type.BIGINT]: (stmt, idx, val) => duck.duck_bind_i64(stmt, idx, BigInt(val)),
-  [Type.UTINYINT]: (stmt, idx, val) => duck.duck_bind_u8(stmt, idx, val >>> 0),
-  [Type.USMALLINT]: (stmt, idx, val) => duck.duck_bind_u16(stmt, idx, val >>> 0),
-  [Type.UINTEGER]: (stmt, idx, val) => duck.duck_bind_u32(stmt, idx, val >>> 0),
-  [Type.UBIGINT]: (stmt, idx, val) => duck.duck_bind_u64(stmt, idx, BigInt(val)),
-  [Type.FLOAT]: (stmt, idx, val) => duck.duck_bind_f32(stmt, idx, val),
-  [Type.DOUBLE]: (stmt, idx, val) => duck.duck_bind_f64(stmt, idx, val),
-  [Type.DECIMAL]: (stmt, idx, val) => duck.duck_bind_f64(stmt, idx, val),
-  [Type.VARCHAR]: (stmt, idx, val) => {
-    const bytes = utf8.encode(String(val));
-    return duck.duck_bind_string(stmt, idx, ptr(bytes), bytes.length);
-  },
-  [Type.JSON]: (stmt, idx, val) => {
-    const str = typeof val === 'string' ? val : JSON.stringify(val);
-    const bytes = utf8.encode(str);
-    return duck.duck_bind_string(stmt, idx, ptr(bytes), bytes.length);
-  },
-  [Type.UUID]: (stmt, idx, val) => {
-    const bytes = utf8.encode(String(val));
-    return duck.duck_bind_string(stmt, idx, ptr(bytes), bytes.length);
-  },
-  [Type.TIMESTAMP]: (stmt, idx, val) => duck.duck_bind_timestamp(stmt, idx, BigInt(val) * 1000n),
-  [Type.DATE]: (stmt, idx, val) => duck.duck_bind_date(stmt, idx, Math.floor(val / 86400000)),
-  [Type.TIME]: (stmt, idx, val) => duck.duck_bind_time(stmt, idx, BigInt(val) * 1000n),
-};
-
-// Default extractor for unknown types
-function defaultExtractor(r, c, row) {
-  const p = duck.duck_value_string_internal(r, c, row);
-  return p ? new CString(p) : null;
-}
-
-// Bind a value based on its JS type and param type
-function bindValue(stmt, idx, val, paramType) {
-  if (val === null || val === undefined) {
-    return duck.duck_bind_null(stmt, idx);
-  }
-
-  const binder = binders[paramType];
-  if (binder) {
-    return binder(stmt, idx, val);
-  }
-
-  // Fallback: infer from JS type
-  const t = typeof val;
-  if (t === 'boolean') return duck.duck_bind_bool(stmt, idx, val);
-  if (t === 'number') {
-    if (Number.isInteger(val)) {
-      return duck.duck_bind_i64(stmt, idx, BigInt(val));
-    }
-    return duck.duck_bind_f64(stmt, idx, val);
-  }
-  if (t === 'bigint') return duck.duck_bind_i64(stmt, idx, val);
-  if (t === 'string') {
-    const bytes = utf8.encode(val);
-    return duck.duck_bind_string(stmt, idx, ptr(bytes), bytes.length);
-  }
-
-  // Object -> JSON
-  const bytes = utf8.encode(JSON.stringify(val));
-  return duck.duck_bind_string(stmt, idx, ptr(bytes), bytes.length);
-}
+const utf8Encoder = new TextEncoder();
 
 /**
  * Open a DuckDB database
  * @param {string|null} path - Path to database file, or null/:memory: for in-memory
+ * @returns {Database}
  */
 export function open(path) {
   return new Database(path);
 }
 
 class Database {
-  #ptr;
+  #handle;
 
   constructor(path) {
-    const p = path === null || path === ':memory:'
-      ? 0
-      : ptr(utf8.encode(path + '\0'));
-    this.#ptr = duck.duck_open(p);
-    if (this.#ptr === 0) throw new Error('Failed to open database');
+    const dbPath = path === null || path === ':memory:' ? null : path;
+    const pathBytes = dbPath ? utf8Encoder.encode(dbPath + '\0') : null;
+    this.#handle = lib.duck_open(pathBytes ? ptr(pathBytes) : null);
+    if (this.#handle === 0n || this.#handle === 0) {
+      throw new Error('Failed to open database');
+    }
   }
 
+  get handle() { return this.#handle; }
+
   connect() {
-    return new Connection(this.#ptr);
+    return new Connection(this.#handle);
   }
 
   close() {
-    if (this.#ptr) {
-      duck.duck_close(this.#ptr);
-      this.#ptr = 0;
+    if (this.#handle) {
+      lib.duck_close(this.#handle);
+      this.#handle = null;
     }
   }
 }
 
-class Connection {
-  #ptr;
+// DuckDB type constants
+const DUCKDB_TYPE = {
+  INVALID: 0, BOOLEAN: 1, TINYINT: 2, SMALLINT: 3, INTEGER: 4, BIGINT: 5,
+  UTINYINT: 6, USMALLINT: 7, UINTEGER: 8, UBIGINT: 9, FLOAT: 10, DOUBLE: 11,
+  TIMESTAMP: 12, DATE: 13, TIME: 14, INTERVAL: 15, HUGEINT: 16, VARCHAR: 17,
+  BLOB: 18, DECIMAL: 19, TIMESTAMP_S: 20, TIMESTAMP_MS: 21, TIMESTAMP_NS: 22,
+  ENUM: 23, LIST: 24, STRUCT: 25, MAP: 26, UUID: 27,
+};
 
-  constructor(db) {
-    this.#ptr = duck.duck_connect(db);
-    if (this.#ptr === 0) throw new Error('Failed to connect to database');
-  }
+class Connection {
+  #handle;
 
-  query(sql) {
-    const sqlPtr = ptr(utf8.encode(sql + '\0'));
-    const result = duck.duck_query(this.#ptr, sqlPtr);
-
-    // Check for error
-    const errPtr = duck.duck_result_error(result);
-    if (errPtr) {
-      const err = new CString(errPtr);
-      duck.duck_free_result(result);
-      throw new Error(err.toString());
+  constructor(dbHandle) {
+    this.#handle = lib.duck_connect(dbHandle);
+    if (this.#handle === 0n || this.#handle === 0) {
+      throw new Error('Failed to create connection');
     }
+  }
 
-    // Extract rows
-    const rowCount = Number(duck.duck_row_count(result));
-    const colCount = Number(duck.duck_column_count(result));
-
-    if (rowCount === 0) {
-      duck.duck_free_result(result);
-      return [];
-    }
+  get handle() { return this.#handle; }
 
-    // Get column info
-    const columns = [];
-    const types = [];
-    const extract = [];
+  /**
+   * Execute SQL and return rows as array of objects
+   * @param {string} sql - SQL query
+   * @returns {object[]} Array of row objects
+   */
+  query(sql) {
+    const sqlBytes = utf8Encoder.encode(sql + '\0');
+    const result = lib.duck_query(this.#handle, ptr(sqlBytes));
+
+    try {
+      // Check for error
+      const errorPtr = lib.duck_result_error(result);
+      if (errorPtr) {
+        throw new Error(new CString(errorPtr).toString());
+      }
 
-    for (let c = 0; c < colCount; c++) {
-      columns.push(new CString(duck.duck_column_name(result, c)).toString());
-      const type = duck.duck_column_type(result, c);
-      types.push(type);
-      extract.push(extractors[type] || defaultExtractor);
-    }
+      const rowCount = Number(lib.duck_row_count(result));
+      const colCount = Number(lib.duck_column_count(result));
 
-    // Extract all rows
-    const rows = new Array(rowCount);
-    for (let r = 0; r < rowCount; r++) {
-      const row = {};
+      // Get column names and types
+      const columns = [];
+      const types = [];
       for (let c = 0; c < colCount; c++) {
-        if (duck.duck_value_is_null(result, c, r)) {
-          row[columns[c]] = null;
-        } else {
-          row[columns[c]] = extract[c](result, c, r);
-        }
+        const namePtr = lib.duck_column_name(result, BigInt(c));
+        columns.push(namePtr ? new CString(namePtr).toString() : `col${c}`);
+        types.push(Number(lib.duck_column_type(result, BigInt(c))));
       }
-      rows[r] = row;
-    }
-
-    duck.duck_free_result(result);
-    return rows;
-  }
 
-  prepare(sql) {
-    const sqlPtr = ptr(utf8.encode(sql + '\0'));
-    const stmt = duck.duck_prepare(this.#ptr, sqlPtr);
+      // Build row objects
+      const rows = [];
+      for (let r = 0; r < rowCount; r++) {
+        const row = {};
+        for (let c = 0; c < colCount; c++) {
+          const col = BigInt(c);
+          const rowIdx = BigInt(r);
+
+          if (lib.duck_value_is_null(result, col, rowIdx)) {
+            row[columns[c]] = null;
+          } else {
+            const type = types[c];
+            switch (type) {
+              case DUCKDB_TYPE.BOOLEAN:
+                row[columns[c]] = lib.duck_value_boolean(result, col, rowIdx);
+                break;
+              case DUCKDB_TYPE.TINYINT:
+              case DUCKDB_TYPE.SMALLINT:
+              case DUCKDB_TYPE.INTEGER:
+              case DUCKDB_TYPE.BIGINT:
+              case DUCKDB_TYPE.UTINYINT:
+              case DUCKDB_TYPE.USMALLINT:
+              case DUCKDB_TYPE.UINTEGER:
+              case DUCKDB_TYPE.UBIGINT:
+              case DUCKDB_TYPE.DATE:
+              case DUCKDB_TYPE.TIME:
+              case DUCKDB_TYPE.TIMESTAMP:
+              case DUCKDB_TYPE.TIMESTAMP_S:
+              case DUCKDB_TYPE.TIMESTAMP_MS:
+              case DUCKDB_TYPE.TIMESTAMP_NS:
+                row[columns[c]] = Number(lib.duck_value_int64(result, col, rowIdx));
+                break;
+              case DUCKDB_TYPE.FLOAT:
+              case DUCKDB_TYPE.DOUBLE:
+              case DUCKDB_TYPE.DECIMAL:
+                row[columns[c]] = lib.duck_value_double(result, col, rowIdx);
+                break;
+              default:
+                // VARCHAR, BLOB, UUID, etc - get as string
+                const strPtr = lib.duck_value_varchar(result, col, rowIdx);
+                if (strPtr) {
+                  row[columns[c]] = new CString(strPtr).toString();
+                  lib.duck_free(strPtr);  // Free the allocated string
+                } else {
+                  row[columns[c]] = null;
+                }
+            }
+          }
+        }
+        rows.push(row);
+      }
 
-    const errPtr = duck.duck_prepare_error(stmt);
-    if (errPtr) {
-      const err = new CString(errPtr);
-      duck.duck_free_prepare(stmt);
-      throw new Error(err.toString());
+      return rows;
+    } finally {
+      lib.duck_free_result(result);
     }
-
-    return new PreparedStatement(stmt);
   }
 
   close() {
-    if (this.#ptr) {
-      duck.duck_disconnect(this.#ptr);
-      this.#ptr = 0;
+    if (this.#handle) {
+      lib.duck_disconnect(this.#handle);
+      this.#handle = null;
     }
   }
 }
 
-class PreparedStatement {
-  #ptr;
-  #paramCount;
-  #paramTypes;
-
-  constructor(ptr) {
-    this.#ptr = ptr;
-    this.#paramCount = Number(duck.duck_nparams(ptr));
-    this.#paramTypes = [];
-    for (let i = 0; i < this.#paramCount; i++) {
-      this.#paramTypes.push(duck.duck_param_type(ptr, i + 1));
-    }
-  }
-
-  query(...params) {
-    // Bind parameters
-    for (let i = 0; i < params.length; i++) {
-      const paramType = this.#paramTypes[i] || Type.VARCHAR;
-      if (!bindValue(this.#ptr, i + 1, params[i], paramType)) {
-        throw new Error(`Failed to bind parameter ${i + 1}`);
-      }
-    }
-
-    // Execute
-    const result = duck.duck_execute_prepared(this.#ptr);
-
-    // Check for error
-    const errPtr = duck.duck_result_error(result);
-    if (errPtr) {
-      const err = new CString(errPtr);
-      duck.duck_free_result(result);
-      throw new Error(err.toString());
-    }
-
-    // Extract rows
-    const rowCount = Number(duck.duck_row_count(result));
-    const colCount = Number(duck.duck_column_count(result));
-
-    if (rowCount === 0) {
-      duck.duck_free_result(result);
-      return [];
-    }
-
-    // Get column info
-    const columns = [];
-    const types = [];
-    const extract = [];
+/**
+ * Execute SQL and return binary result (DuckDB UI protocol format)
+ *
+ * @param {bigint|number} connHandle - Connection handle from conn.handle
+ * @param {string} sql - SQL query to execute
+ * @param {number} rowLimit - Maximum rows to return (default 10000)
+ * @returns {ArrayBuffer} - Binary result ready for HTTP response
+ */
+export function queryBinary(connHandle, sql, rowLimit = 10000) {
+  const sqlBytes = utf8Encoder.encode(sql + '\0');
+  const bytesWritten = lib.duck_query_binary(
+    connHandle,
+    ptr(sqlBytes),
+    ptr(sharedBuffer),
+    sharedBuffer.length,
+    BigInt(rowLimit)
+  );
+
+  // Return a copy of the used portion
+  return sharedBuffer.slice(0, Number(bytesWritten)).buffer;
+}
 
-    for (let c = 0; c < colCount; c++) {
-      columns.push(new CString(duck.duck_column_name(result, c)).toString());
-      const type = duck.duck_column_type(result, c);
-      types.push(type);
-      extract.push(extractors[type] || defaultExtractor);
-    }
+/**
+ * Tokenize SQL and return binary result (DuckDB UI protocol format)
+ *
+ * @param {string} sql - SQL to tokenize
+ * @returns {ArrayBuffer} - Binary result ready for HTTP response
+ */
+export function tokenize(sql) {
+  const sqlBytes = utf8Encoder.encode(sql);
+  const bytesWritten = lib.duck_tokenize(
+    ptr(sqlBytes),
+    sqlBytes.length,
+    ptr(sharedBuffer),
+    sharedBuffer.length
+  );
+
+  return sharedBuffer.slice(0, Number(bytesWritten)).buffer;
+}
 
-    // Extract all rows
-    const rows = new Array(rowCount);
-    for (let r = 0; r < rowCount; r++) {
-      const row = {};
-      for (let c = 0; c < colCount; c++) {
-        if (duck.duck_value_is_null(result, c, r)) {
-          row[columns[c]] = null;
-        } else {
-          row[columns[c]] = extract[c](result, c, r);
-        }
-      }
-      rows[r] = row;
-    }
+/**
+ * Create an empty binary result (for /ddb/interrupt)
+ * @returns {ArrayBuffer}
+ */
+export function emptyResult() {
+  const bytesWritten = lib.duck_empty_result(
+    ptr(sharedBuffer),
+    sharedBuffer.length
+  );
+  return sharedBuffer.slice(0, Number(bytesWritten)).buffer;
+}
 
-    duck.duck_free_result(result);
-    return rows;
-  }
+/**
+ * Create an error binary result
+ * @param {string} message - Error message
+ * @returns {ArrayBuffer}
+ */
+export function errorResult(message) {
+  const msgBytes = utf8Encoder.encode(message + '\0');
+  const bytesWritten = lib.duck_error_result(
+    ptr(msgBytes),
+    ptr(sharedBuffer),
+    sharedBuffer.length
+  );
+  return sharedBuffer.slice(0, Number(bytesWritten)).buffer;
+}
 
-  close() {
-    if (this.#ptr) {
-      duck.duck_free_prepare(this.#ptr);
-      this.#ptr = 0;
-    }
-  }
+/**
+ * Resize the shared buffer (for very large results)
+ * @param {number} size - New buffer size in bytes
+ */
+export function setBufferSize(size) {
+  sharedBuffer = new Uint8Array(size);
 }
 
-export { Type };
+// Export types for compatibility
+export const Type = {
+  BOOLEAN: 10,
+  TINYINT: 11,
+  SMALLINT: 12,
+  INTEGER: 13,
+  BIGINT: 14,
+  DATE: 15,
+  TIME: 16,
+  TIMESTAMP_SEC: 17,
+  TIMESTAMP_MS: 18,
+  TIMESTAMP: 19,
+  TIMESTAMP_NS: 20,
+  DECIMAL: 21,
+  FLOAT: 22,
+  DOUBLE: 23,
+  CHAR: 24,
+  VARCHAR: 25,
+  BLOB: 26,
+  INTERVAL: 27,
+  UTINYINT: 28,
+  USMALLINT: 29,
+  UINTEGER: 30,
+  UBIGINT: 31,
+  TIMESTAMP_TZ: 32,
+  TIME_TZ: 34,
+  HUGEINT: 50,
+  UUID: 54,
+};
+
+export default { open, queryBinary, tokenize, emptyResult, errorResult, setBufferSize, Type };