⚡ [Performance] Batch execution of DROP INDEX operations (#254)

* perf: Batch execution of DROP INDEX operations

Batched multiple `DROP INDEX IF EXISTS` statements into a single `executeQuery`
call to eliminate N+1 query transaction overhead for multiple dependent indexes.

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

* perf: Batch execution of DROP INDEX operations securely

Batches multiple `DROP INDEX IF EXISTS` statements into a single `executeQuery` call within the transaction block. This safely eliminates N+1 query overhead for multiple dependent indexes while preserving atomicity in case of rollback.

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

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: zknpr

src/core/sqlite-db.ts

@@ -646,17 +646,18 @@ class WasmDatabaseEngine implements DatabaseOperations {
 
     const escapedTable = escapeIdentifier(table);
 
-    // Drop specified dependent indexes first
-    if (dropDependentIndexes && dropDependentIndexes.length > 0) {
-      for (const indexName of dropDependentIndexes) {
-        await this.executeQuery(`DROP INDEX IF EXISTS ${escapeIdentifier(indexName)}`);
-      }
-    }
-
     // Now drop the columns within a single transaction for better performance
     // This avoids N+1 query transaction overhead for multiple columns
     await this.executeQuery('BEGIN TRANSACTION');
     try {
+      // Drop specified dependent indexes first inside the transaction
+      if (dropDependentIndexes && dropDependentIndexes.length > 0) {
+        const dropIndexStatements = dropDependentIndexes
+          .map((indexName) => `DROP INDEX IF EXISTS ${escapeIdentifier(indexName)};`)
+          .join('\n');
+        await this.executeQuery(dropIndexStatements);
+      }
+
       for (const col of columns) {
         const sql = `ALTER TABLE ${escapedTable} DROP COLUMN ${escapeIdentifier(col)}`;
         await this.executeQuery(sql);

tests/performance/index_drop_benchmark.ts

@@ -0,0 +1,86 @@
+import fs from 'fs';
+import path from 'path';
+import { createDatabaseEngine, WasmDatabaseEngine } from '../../src/core/sqlite-db';
+
+async function setupTestDb(db: WasmDatabaseEngine, numIndexes: number) {
+    await db.executeQuery(`DROP TABLE IF EXISTS test_table`);
+    await db.executeQuery(`CREATE TABLE test_table (id INTEGER PRIMARY KEY, col TEXT)`);
+    for (let i = 0; i < numIndexes; i++) {
+        await db.executeQuery(`CREATE INDEX idx_${i} ON test_table(col)`);
+    }
+    const indexNames = Array.from({ length: numIndexes }, (_, i) => `idx_${i}`);
+    return indexNames;
+}
+
+async function measureUnbatched(db: WasmDatabaseEngine, indexNames: string[]) {
+    const start = performance.now();
+    for (const indexName of indexNames) {
+        await db.executeQuery(`DROP INDEX IF EXISTS "${indexName}"`);
+    }
+    return performance.now() - start;
+}
+
+async function measureBatched(db: WasmDatabaseEngine, indexNames: string[]) {
+    const start = performance.now();
+    if (indexNames.length > 0) {
+        const dropStatements = indexNames.map(name => `DROP INDEX IF EXISTS "${name}";`).join('\n');
+        await db.executeQuery(dropStatements);
+    }
+    return performance.now() - start;
+}
+
+async function runBenchmark() {
+    console.log('Starting Index Drop Benchmark (Hygienic)...');
+
+    try {
+        const wasmBinary = fs.readFileSync(path.resolve(__dirname, '../../node_modules/sql.js/dist/sql-wasm.wasm'));
+        const engineResult = await createDatabaseEngine({ wasmBinary });
+        const db = engineResult.operations as WasmDatabaseEngine;
+
+        const numIndexes = 50;
+        const iterations = 10;
+
+        console.log('Warming up...');
+        for (let i = 0; i < 3; i++) {
+            let idxs = await setupTestDb(db, numIndexes);
+            await measureUnbatched(db, idxs);
+            idxs = await setupTestDb(db, numIndexes);
+            await measureBatched(db, idxs);
+        }
+
+        let unbatchedTotal = 0;
+        let batchedTotal = 0;
+
+        console.log(`Running ${iterations} iterations (Alternating)...`);
+        for (let i = 0; i < iterations; i++) {
+            // Unbatched first
+            let idxs = await setupTestDb(db, numIndexes);
+            unbatchedTotal += await measureUnbatched(db, idxs);
+
+            // Batched second
+            idxs = await setupTestDb(db, numIndexes);
+            batchedTotal += await measureBatched(db, idxs);
+
+            // Batched first (reverse order)
+            idxs = await setupTestDb(db, numIndexes);
+            batchedTotal += await measureBatched(db, idxs);
+
+            // Unbatched second
+            idxs = await setupTestDb(db, numIndexes);
+            unbatchedTotal += await measureUnbatched(db, idxs);
+        }
+
+        const avgUnbatched = unbatchedTotal / (iterations * 2);
+        const avgBatched = batchedTotal / (iterations * 2);
+
+        console.log('--- Results ---');
+        console.log(`Average Unbatched (${numIndexes} indexes): ${avgUnbatched.toFixed(2)}ms`);
+        console.log(`Average Batched (${numIndexes} indexes): ${avgBatched.toFixed(2)}ms`);
+        console.log(`Improvement: ${((avgUnbatched - avgBatched) / avgUnbatched * 100).toFixed(2)}%`);
+
+    } catch (e) {
+        console.error('Benchmark failed:', e);
+    }
+}
+
+runBenchmark();