fix(sqlite): run multi-statement batches in source order (#470)

The SQLite connector split a batch into writes and reads and ran all
writes before any reads, so `SELECT ...; DELETE ...; SELECT ...` read
the table after the DELETE and returned an empty first result. Run each
statement in the order written instead, matching the PostgreSQL
connector. The per-statement read-only backstop and maxRows probe are
unchanged.

Author: vishalhabib99

src/connectors/__tests__/sqlite.integration.test.ts

@@ -252,8 +252,7 @@ describe('SQLite Connector Integration Tests', () => {
         SELECT COUNT(*) as total FROM users WHERE email LIKE 'multi%';
       `, {});
 
-      // Two writes then one read, matching both source order and SQLite's
-      // writes-then-reads execution order here.
+      // Two writes then one read, in source order.
       expect(result.resultSets).toHaveLength(3);
       expect(result.resultSets[0]).toEqual({
         sql: "INSERT INTO users (name, email, age) VALUES ('Multi User 1', '[email protected]', 30)",
@@ -269,6 +268,30 @@ describe('SQLite Connector Integration Tests', () => {
       expect(Number(result.resultSets[2].rows[0].total)).toBe(2);
     });
 
+    it('should execute multi-statement batches in source order', async () => {
+      await sqliteTest.connector.executeSQL(`
+        CREATE TABLE order_check (a INTEGER);
+        INSERT INTO order_check VALUES (1), (2), (3);
+      `, {});
+
+      const result = await sqliteTest.connector.executeSQL(`
+        SELECT a AS before_delete FROM order_check ORDER BY a;
+        DELETE FROM order_check;
+        SELECT COUNT(*) AS after_delete FROM order_check;
+      `, {});
+
+      expect(result.resultSets.map((rs) => rs.sql)).toEqual([
+        'SELECT a AS before_delete FROM order_check ORDER BY a',
+        'DELETE FROM order_check',
+        'SELECT COUNT(*) AS after_delete FROM order_check',
+      ]);
+      expect(result.resultSets[0].rows.map((row) => Number(row.before_delete))).toEqual([1, 2, 3]);
+      expect(result.resultSets[1].rowCount).toBe(3);
+      expect(Number(result.resultSets[2].rows[0].after_delete)).toBe(0);
+
+      await sqliteTest.connector.executeSQL('DROP TABLE order_check', {});
+    });
+
     it('should handle SQLite foreign key constraints', async () => {
       // Enable foreign key constraints
       await sqliteTest.connector.executeSQL('PRAGMA foreign_keys = ON', {});
@@ -412,25 +435,23 @@ describe('SQLite Connector Integration Tests', () => {
         INSERT INTO users (name, email, age) VALUES ('Multi Test 2', '[email protected]', 35);
       `, { maxRows: 1 });
 
-      // SQLite's connector executes all write statements first, then all
-      // read statements, regardless of source order - so resultSets order
-      // here is [INSERT 'Multi Test 1', INSERT 'Multi Test 2', SELECT],
-      // not the source order [INSERT, SELECT, INSERT]. Both inserts have
-      // already run by the time the SELECT executes.
+      // Statements run in source order [INSERT, SELECT, INSERT], so only the
+      // first insert has run by the time the SELECT executes.
       expect(result.resultSets).toHaveLength(3);
       expect(result.resultSets[0]).toEqual({
         sql: "INSERT INTO users (name, email, age) VALUES ('Multi Test 1', '[email protected]', 30)",
         rows: [],
         rowCount: 1,
       });
-      expect(result.resultSets[1]).toEqual({
+      // Should return only 1 row from the SELECT statement
+      expect(result.resultSets[1].sql).toBe("SELECT name FROM users WHERE email LIKE '%@test.com' ORDER BY name");
+      expect(result.resultSets[1].rows).toHaveLength(1);
+      expect(result.resultSets[1].rows[0].name).toBe('Multi Test 1');
+      expect(result.resultSets[2]).toEqual({
         sql: "INSERT INTO users (name, email, age) VALUES ('Multi Test 2', '[email protected]', 35)",
         rows: [],
         rowCount: 1,
       });
-      // Should return only 1 row from the SELECT statement
-      expect(result.resultSets[2].rows).toHaveLength(1);
-      expect(result.resultSets[2].rows[0].name).toBe('Multi Test 1');
     });
 
   });

src/connectors/sqlite/index.ts

@@ -541,51 +541,32 @@ export class SQLiteConnector implements Connector {
           throw new Error("Parameters are not supported for multi-statement queries in SQLite");
         }
 
-        // Use native .exec() for optimal performance
-        // Note: .exec() doesn't return results, so we need to handle SELECT statements differently
-        const readStatements = [];
-        const writeStatements = [];
-
-        // Separate read and write operations
-        for (const statement of statements) {
-          if (this.returnsRows(statement)) {
-            readStatements.push(statement);
-          } else {
-            writeStatements.push(statement);
-          }
-        }
-
-        // Execute write statements individually to track changes. Each
-        // statement becomes its own result set, in the order actually run -
-        // note that's writes-then-reads (see readStatements/writeStatements
-        // split above), not necessarily the original source order.
+        // Execute each statement individually, in source order, so a later
+        // statement sees the effects of earlier ones and result sets line up
+        // with the batch as written.
         const resultSets: SQLResultSet[] = [];
-        for (const statement of writeStatements) {
+        for (const statement of statements) {
           // Re-assert the read-only backstop before each statement so an earlier
           // statement in the batch (e.g. `PRAGMA query_only = OFF` / `query_only(0)`)
           // cannot disable it for the ones that follow.
           if (options.readonly) {
             this.db.exec("PRAGMA query_only = ON");
           }
-          const result = this.prepare(statement).run();
-          resultSets.push({ sql: statement, rows: [], rowCount: Number(result.changes) });
-        }
-
-        // Execute read statements individually to collect results
-        for (const statement of readStatements) {
-          if (options.readonly) {
-            this.db.exec("PRAGMA query_only = ON");
+          if (this.returnsRows(statement)) {
+            // Apply maxRows limit (with a truncation probe row) to SELECT queries if specified
+            const { sql: processedStatement, probeApplied } = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
+              statement,
+              options.maxRows,
+              "sqlite"
+            );
+            const rows = this.prepare(processedStatement).all();
+            const resultSet: SQLResultSet = { sql: statement, rows, rowCount: rows.length };
+            SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
+            resultSets.push(resultSet);
+          } else {
+            const result = this.prepare(statement).run();
+            resultSets.push({ sql: statement, rows: [], rowCount: Number(result.changes) });
           }
-          // Apply maxRows limit (with a truncation probe row) to SELECT queries if specified
-          const { sql: processedStatement, probeApplied } = SQLRowLimiter.applyMaxRowsWithTruncationProbe(
-            statement,
-            options.maxRows,
-            "sqlite"
-          );
-          const rows = this.prepare(processedStatement).all();
-          const resultSet: SQLResultSet = { sql: statement, rows, rowCount: rows.length };
-          SQLRowLimiter.flagTruncation(resultSet, options.maxRows, probeApplied);
-          resultSets.push(resultSet);
         }
 
         return { resultSets };