perf: Optimize updateCellBatch via prepared statement reuse in nativeWorker

Updates updateCellBatch to group by column and operation and pass a
`paramsList` to the native worker `execBatch` API. This allows the worker
to prepare a single UPDATE statement and execute it multiple times for each row,
significantly cutting down parsing overhead compared to individual UPDATE
statements for each cell update.

Co-authored-by: zknpr <96851588+zknpr@users.noreply.github.com>

Author: google-labs-jules[bot]

natives/native-worker.js

@@ -424,14 +424,27 @@ async function handleRequest(request) {
 
       case "execBatch": {
         // Execute a batch of statements in a transaction
-        // args: [items: { sql: string, params?: any[] }[]]
+        // args: [items: { sql: string, params?: any[], paramsList?: any[][] }[]]
         const [items] = args;
         if (!db) throw new Error("Database not open");
 
         db.exec("BEGIN TRANSACTION");
         try {
           for (const item of items) {
-             executeStatement(db, item.sql, item.params);
+             if (item.paramsList && item.paramsList.length > 0) {
+                 const stmt = db.prepare(item.sql);
+                 try {
+                     for (const params of item.paramsList) {
+                         if (params && params.length > 0) stmt.run(...params);
+                         else stmt.run();
+                     }
+                 } finally {
+                     if (typeof stmt.free === 'function') stmt.free();
+                     else if (typeof stmt.finalize === 'function') stmt.finalize();
+                 }
+             } else {
+                 executeStatement(db, item.sql, item.params);
+             }
           }
           db.exec("COMMIT");
           result = { success: true };

src/nativeWorker.ts

@@ -1070,28 +1070,38 @@ export async function createNativeDatabaseConnection(
         updateCellBatch: async (table: string, updates: CellUpdate[]) => {
           if (updates.length === 0) return;
 
-          const batchItems: { sql: string; params: CellValue[] }[] = [];
+          const batchItems: { sql: string; paramsList?: CellValue[][], params?: CellValue[] }[] = [];
           const escapedTable = escapeIdentifier(table);
 
+          const updatesByColumn = new Map<string, CellUpdate[]>();
           for (const update of updates) {
-            // Validate rowId is a number
-            const rowIdNum = validateRowId(update.rowId);
+            const key = `${update.column}|${update.operation || 'set'}`;
+            if (!updatesByColumn.has(key)) {
+                updatesByColumn.set(key, []);
+            }
+            updatesByColumn.get(key)!.push(update);
+          }
 
-            const escapedColumn = escapeIdentifier(update.column);
+          for (const [key, columnUpdates] of updatesByColumn.entries()) {
+            const column = columnUpdates[0].column;
+            const op = columnUpdates[0].operation || 'set';
+            const escapedColumn = escapeIdentifier(column);
             let sql: string;
-            let params: CellValue[];
 
-            if (update.operation === 'json_patch') {
+            if (op === 'json_patch') {
               // json_patch(col, patch)
               sql = `UPDATE ${escapedTable} SET ${escapedColumn} = json_patch(${escapedColumn}, ?) WHERE rowid = ?`;
-              params = [update.value, rowIdNum];
             } else {
               // Standard set
               sql = `UPDATE ${escapedTable} SET ${escapedColumn} = ? WHERE rowid = ?`;
-              params = [update.value, rowIdNum];
             }
 
-            batchItems.push({ sql, params });
+            const paramsList = columnUpdates.map(update => {
+                const rowIdNum = validateRowId(update.rowId);
+                return [update.value, rowIdNum];
+            });
+
+            batchItems.push({ sql, paramsList });
           }
 
           if (batchItems.length > 0) {