@rip-lang/db 1.3.3 → 1.3.4

package/client.rip

@@ -52,6 +52,15 @@ export query = (sql, params = []) ->
   throw new Error data.error if data.error
   data
 
+export bulk = (table, columns, rows) ->
+  res = fetch! "#{dbUrl()}/sql",
+    method: 'POST'
+    headers: { 'Content-Type': 'application/json' }
+    body: JSON.stringify { table, columns, rows }
+  data = res.json!
+  throw new Error data.error if data.error
+  data
+
 materialize = (meta, row) ->
   obj = {}
   for col, i in meta
@@ -258,11 +267,17 @@ export Model = (table, database = null) ->
     findAll! sql, params
 
   insert: (data) ->
-    keys = Object.keys(data).filter (k) -> data[k] isnt undefined
-    cols = keys.map((k) -> "\"#{k}\"").join(', ')
-    refs = keys.map((_, i) -> "$#{i + 1}").join(', ')
-    vals = keys.map (k) -> data[k]
-    findOne! "INSERT INTO #{tableName} (#{cols}) VALUES (#{refs}) RETURNING *", vals
+    if Array.isArray(data)
+      return { rows: 0 } if data.length is 0
+      columns = Object.keys(data[0]).filter (k) -> data[0][k] isnt undefined
+      rows = data.map (row) -> columns.map (k) -> row[k]
+      bulk! table, columns, rows
+    else
+      keys = Object.keys(data).filter (k) -> data[k] isnt undefined
+      cols = keys.map((k) -> "\"#{k}\"").join(', ')
+      refs = keys.map((_, i) -> "$#{i + 1}").join(', ')
+      vals = keys.map (k) -> data[k]
+      findOne! "INSERT INTO #{tableName} (#{cols}) VALUES (#{refs}) RETURNING *", vals
 
   update: (id, data) ->
     keys = Object.keys(data).filter (k) -> data[k] isnt undefined
@@ -271,19 +286,37 @@ export Model = (table, database = null) ->
     findOne! "UPDATE #{tableName} SET #{sets} WHERE id = $1 RETURNING *", [id, ...vals]
 
   upsert: (data, opts = {}) ->
-    keys = Object.keys(data).filter (k) -> data[k] isnt undefined
-    cols = keys.map((k) -> "\"#{k}\"").join(', ')
-    refs = keys.map((_, i) -> "$#{i + 1}").join(', ')
-    vals = keys.map (k) -> data[k]
-
-    conflict = opts.on or opts.conflict
-    sql = "INSERT INTO #{tableName} (#{cols}) VALUES (#{refs})"
-    if conflict
-      updateCols = keys.filter((k) -> k isnt conflict)
-      sets = updateCols.map((k) -> "\"#{k}\" = EXCLUDED.\"#{k}\"").join(', ')
-      sql += " ON CONFLICT (\"#{conflict}\") DO UPDATE SET #{sets}"
-    sql += " RETURNING *"
-    findOne! sql, vals
+    if Array.isArray(data)
+      return [] if data.length is 0
+      keys = Object.keys(data[0]).filter (k) -> data[0][k] isnt undefined
+      cols = keys.map((k) -> "\"#{k}\"").join(', ')
+      allVals = []
+      valueTuples = data.map (row, rowIdx) ->
+        refs = keys.map (k, colIdx) ->
+          allVals.push(row[k])
+          "$#{rowIdx * keys.length + colIdx + 1}"
+        "(#{refs.join(', ')})"
+      sql = "INSERT INTO #{tableName} (#{cols}) VALUES #{valueTuples.join(', ')}"
+      conflict = opts.on or opts.conflict
+      if conflict
+        updateCols = keys.filter((k) -> k isnt conflict)
+        sets = updateCols.map((k) -> "\"#{k}\" = EXCLUDED.\"#{k}\"").join(', ')
+        sql += " ON CONFLICT (\"#{conflict}\") DO UPDATE SET #{sets}"
+      sql += " RETURNING *"
+      findAll! sql, allVals
+    else
+      keys = Object.keys(data).filter (k) -> data[k] isnt undefined
+      cols = keys.map((k) -> "\"#{k}\"").join(', ')
+      refs = keys.map((_, i) -> "$#{i + 1}").join(', ')
+      vals = keys.map (k) -> data[k]
+      conflict = opts.on or opts.conflict
+      sql = "INSERT INTO #{tableName} (#{cols}) VALUES (#{refs})"
+      if conflict
+        updateCols = keys.filter((k) -> k isnt conflict)
+        sets = updateCols.map((k) -> "\"#{k}\" = EXCLUDED.\"#{k}\"").join(', ')
+        sql += " ON CONFLICT (\"#{conflict}\") DO UPDATE SET #{sets}"
+      sql += " RETURNING *"
+      findOne! sql, vals
 
   destroy: (id) ->
     findOne! "DELETE FROM #{tableName} WHERE id = $1 RETURNING *", [id]

package/db.rip

@@ -149,20 +149,54 @@ executeSQL = (sql, params = []) ->
   catch err
     { error: err.message }
 
+# Bulk insert via Appender API (fastest path for pure inserts)
+executeAppend = (table, columns, rows) ->
+  console.log "APPEND #{table} (#{rows.length} rows)"
+  startTime = Date.now()
+  try
+    await conn.append(table, columns, rows)
+    { rows: rows.length, time: (Date.now() - startTime) / 1000 }
+  catch err
+    { error: err.message }
+
+# Batch execute a prepared statement with multiple param sets
+executeBatch = (sql, paramSets) ->
+  logSQL sql
+  startTime = Date.now()
+  try
+    await conn.queryBatch(sql, paramSets)
+    { rows: paramSets.length, time: (Date.now() - startTime) / 1000 }
+  catch err
+    { error: err.message }
+
 # ==============================================================================
 # JSON Endpoints (for custom apps)
 # ==============================================================================
 
-# POST /sql — Execute SQL with optional parameters
+# POST /sql — Execute SQL, bulk append, or batch prepared statements
+#
+# Shapes:
+#   { sql }                          → raw execution
+#   { sql, params: [...] }           → prepared statement
+#   { sql, params: [[...], [...]] }  → batch prepared (reuse stmt)
+#   { table, columns, rows }         → appender API (fastest insert)
 post '/sql' ->
   contentType = @req.header('content-type') or ''
   if contentType.includes('application/json')
     body = read()
+
+    if body?.table and body?.rows
+      return executeAppend body.table, body.columns, body.rows
+
     sql = body?.sql or body
     params = body?.params or []
+
+    if params.length > 0 and Array.isArray(params[0])
+      return executeBatch sql, params
   else
     sql = read 'body', 'string'
     params = []
+
   return { error: 'Empty query' } unless sql
   executeSQL sql, params
 

package/lib/duckdb.mjs

@@ -89,6 +89,21 @@ const lib = dlopen(libPath, {
   duckdb_bind_double:      { args: ['ptr', 'u64', 'f64'], returns: 'i32' },
   duckdb_bind_varchar:     { args: ['ptr', 'u64', 'ptr'], returns: 'i32' },
   duckdb_execute_prepared: { args: ['ptr', 'ptr'], returns: 'i32' },
+  duckdb_clear_bindings:   { args: ['ptr'], returns: 'i32' },
+
+  // Appender API
+  duckdb_appender_create:  { args: ['ptr', 'ptr', 'ptr', 'ptr'], returns: 'i32' },
+  duckdb_appender_error:   { args: ['ptr'], returns: 'ptr' },
+  duckdb_appender_flush:   { args: ['ptr'], returns: 'i32' },
+  duckdb_appender_close:   { args: ['ptr'], returns: 'i32' },
+  duckdb_appender_destroy: { args: ['ptr'], returns: 'i32' },
+  duckdb_appender_end_row: { args: ['ptr'], returns: 'i32' },
+  duckdb_append_bool:      { args: ['ptr', 'bool'], returns: 'i32' },
+  duckdb_append_int32:     { args: ['ptr', 'i32'], returns: 'i32' },
+  duckdb_append_int64:     { args: ['ptr', 'i64'], returns: 'i32' },
+  duckdb_append_double:    { args: ['ptr', 'f64'], returns: 'i32' },
+  duckdb_append_varchar:   { args: ['ptr', 'ptr'], returns: 'i32' },
+  duckdb_append_null:      { args: ['ptr'], returns: 'i32' },
 
   // Result inspection
   duckdb_column_count: { args: ['ptr'], returns: 'u64' },
@@ -358,30 +373,7 @@ class Connection {
     const stmtHandle = readPtr(stmtPtr);
 
     try {
-      for (let i = 0; i < params.length; i++) {
-        const paramIdx = BigInt(i + 1);
-        const value = params[i];
-
-        if (value === null || value === undefined) {
-          lib.duckdb_bind_null(stmtHandle, paramIdx);
-        } else if (typeof value === 'boolean') {
-          lib.duckdb_bind_boolean(stmtHandle, paramIdx, value);
-        } else if (typeof value === 'number') {
-          if (Number.isInteger(value)) {
-            lib.duckdb_bind_int64(stmtHandle, paramIdx, BigInt(value));
-          } else {
-            lib.duckdb_bind_double(stmtHandle, paramIdx, value);
-          }
-        } else if (typeof value === 'bigint') {
-          lib.duckdb_bind_int64(stmtHandle, paramIdx, value);
-        } else if (value instanceof Date) {
-          const strBytes = toCString(value.toISOString());
-          lib.duckdb_bind_varchar(stmtHandle, paramIdx, ptr(strBytes));
-        } else {
-          const strBytes = toCString(String(value));
-          lib.duckdb_bind_varchar(stmtHandle, paramIdx, ptr(strBytes));
-        }
-      }
+      this.#bindParams(stmtHandle, params);
 
       const resultPtr = new Uint8Array(64);  // duckdb_result struct is ~48 bytes
       lib.duckdb_execute_prepared(stmtHandle, ptr(resultPtr));
@@ -778,6 +770,156 @@ class Connection {
     return 'UNKNOWN';
   }
 
+  #bindParams(stmtHandle, params) {
+    for (let i = 0; i < params.length; i++) {
+      const paramIdx = BigInt(i + 1);
+      const value = params[i];
+
+      if (value === null || value === undefined) {
+        lib.duckdb_bind_null(stmtHandle, paramIdx);
+      } else if (typeof value === 'boolean') {
+        lib.duckdb_bind_boolean(stmtHandle, paramIdx, value);
+      } else if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+          lib.duckdb_bind_int64(stmtHandle, paramIdx, BigInt(value));
+        } else {
+          lib.duckdb_bind_double(stmtHandle, paramIdx, value);
+        }
+      } else if (typeof value === 'bigint') {
+        lib.duckdb_bind_int64(stmtHandle, paramIdx, value);
+      } else if (value instanceof Date) {
+        const strBytes = toCString(value.toISOString());
+        lib.duckdb_bind_varchar(stmtHandle, paramIdx, ptr(strBytes));
+      } else {
+        const strBytes = toCString(String(value));
+        lib.duckdb_bind_varchar(stmtHandle, paramIdx, ptr(strBytes));
+      }
+    }
+  }
+
+  #appendValue(appenderHandle, value) {
+    if (value === null || value === undefined) {
+      lib.duckdb_append_null(appenderHandle);
+    } else if (typeof value === 'boolean') {
+      lib.duckdb_append_bool(appenderHandle, value);
+    } else if (typeof value === 'number') {
+      if (Number.isInteger(value)) {
+        lib.duckdb_append_int64(appenderHandle, BigInt(value));
+      } else {
+        lib.duckdb_append_double(appenderHandle, value);
+      }
+    } else if (typeof value === 'bigint') {
+      lib.duckdb_append_int64(appenderHandle, value);
+    } else if (value instanceof Date) {
+      const strBytes = toCString(value.toISOString());
+      lib.duckdb_append_varchar(appenderHandle, ptr(strBytes));
+    } else {
+      const strBytes = toCString(String(value));
+      lib.duckdb_append_varchar(appenderHandle, ptr(strBytes));
+    }
+  }
+
+  /**
+   * Bulk insert rows using the DuckDB Appender API (fastest path)
+   * @param {string} table - Table name
+   * @param {string[]} columns - Column names
+   * @param {any[][]} rows - Array of value arrays (positional, matching columns)
+   * @returns {Promise<{rows: number}>}
+   */
+  append(table, columns, rows) {
+    return withLock(() => {
+      const appenderPtr = allocPtr();
+      const tableBytes = toCString(table);
+
+      const status = lib.duckdb_appender_create(this.#handle, null, ptr(tableBytes), ptr(appenderPtr));
+      if (status !== 0) {
+        const handle = readPtr(appenderPtr);
+        if (handle) {
+          const errPtr = lib.duckdb_appender_error(handle);
+          const errMsg = errPtr ? fromCString(errPtr) : 'Failed to create appender';
+          lib.duckdb_appender_destroy(ptr(appenderPtr));
+          throw new Error(errMsg);
+        }
+        throw new Error('Failed to create appender');
+      }
+
+      const appenderHandle = readPtr(appenderPtr);
+
+      try {
+        for (const row of rows) {
+          for (const value of row) {
+            this.#appendValue(appenderHandle, value);
+          }
+          lib.duckdb_appender_end_row(appenderHandle);
+        }
+
+        const flushStatus = lib.duckdb_appender_flush(appenderHandle);
+        if (flushStatus !== 0) {
+          const errPtr = lib.duckdb_appender_error(appenderHandle);
+          const errMsg = errPtr ? fromCString(errPtr) : 'Appender flush failed';
+          throw new Error(errMsg);
+        }
+
+        return { rows: rows.length };
+      } finally {
+        lib.duckdb_appender_destroy(ptr(appenderPtr));
+      }
+    });
+  }
+
+  /**
+   * Execute a prepared statement multiple times with different param sets
+   * @param {string} sql - SQL with $1, $2, ... placeholders
+   * @param {any[][]} paramSets - Array of param arrays
+   * @returns {Promise<{rows: number}>}
+   */
+  queryBatch(sql, paramSets) {
+    return withLock(() => {
+      const stmtPtr = allocPtr();
+      const sqlBytes = toCString(sql);
+
+      const prepStatus = lib.duckdb_prepare(this.#handle, ptr(sqlBytes), ptr(stmtPtr));
+      if (prepStatus !== 0) {
+        const stmtHandle = readPtr(stmtPtr);
+        if (stmtHandle) {
+          const errPtr = lib.duckdb_prepare_error(stmtHandle);
+          const errMsg = errPtr ? fromCString(errPtr) : 'Failed to prepare statement';
+          lib.duckdb_destroy_prepare(ptr(stmtPtr));
+          throw new Error(errMsg);
+        }
+        throw new Error('Failed to prepare statement');
+      }
+
+      const stmtHandle = readPtr(stmtPtr);
+      let totalRows = 0;
+
+      try {
+        for (const params of paramSets) {
+          this.#bindParams(stmtHandle, params);
+
+          const resultPtr = new Uint8Array(64);
+          lib.duckdb_execute_prepared(stmtHandle, ptr(resultPtr));
+
+          const rp = ptr(resultPtr);
+          const errorPtr = lib.duckdb_result_error(rp);
+          if (errorPtr) {
+            const error = fromCString(errorPtr);
+            lib.duckdb_destroy_result(rp);
+            throw new Error(error);
+          }
+
+          lib.duckdb_destroy_result(rp);
+          lib.duckdb_clear_bindings(stmtHandle);
+          totalRows++;
+        }
+
+        return { rows: totalRows };
+      } finally {
+        lib.duckdb_destroy_prepare(ptr(stmtPtr));
+      }
+    });
+  }
+
   close() {
     if (this.#ptrBuf) {
       lib.duckdb_disconnect(ptr(this.#ptrBuf));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rip-lang/db",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "DuckDB server with official DuckDB UI — pure Bun FFI",
   "type": "module",
   "main": "db.rip",