squirreling 0.12.20 → 0.12.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.20",
+  "version": "0.12.21",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -39,11 +39,11 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.8.0",
-    "@vitest/coverage-v8": "4.1.6",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
     "eslint": "9.39.4",
-    "eslint-plugin-jsdoc": "62.9.0",
+    "eslint-plugin-jsdoc": "63.0.0",
     "typescript": "6.0.3",
-    "vitest": "4.1.6"
+    "vitest": "4.1.7"
   }
 }

package/src/execute/aggregates.js

@@ -9,6 +9,9 @@ import { keyify } from './utils.js'
  * @import { HashAggregateNode, ScalarAggregateNode } from '../plan/types.js'
  */
 
+// Yield to the event loop every this many iterations so that aborts can actually fire
+const YIELD_INTERVAL = 4000
+
 /**
  * Projects aggregate columns from a group of rows
  *
@@ -83,8 +86,12 @@ export function executeHashAggregate(plan, context) {
       // Collect all rows
       /** @type {AsyncRow[]} */
       const allRows = []
+      let collectCount = 0
       for await (const row of child.rows()) {
-        if (context.signal?.aborted) return
+        if (++collectCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
         allRows.push(row)
       }
 
@@ -92,14 +99,27 @@ export function executeHashAggregate(plan, context) {
       /** @type {Map<any, AsyncRow[]>} */
       const groups = new Map()
 
-      for (const row of allRows) {
-        const key = keyify(...await Promise.all(plan.groupBy.map(expr => evaluateExpr({ node: expr, row, context }))))
-        let group = groups.get(key)
-        if (!group) {
-          group = []
-          groups.set(key, group)
+      for (let chunkStart = 0; chunkStart < allRows.length; chunkStart += YIELD_INTERVAL) {
+        if (chunkStart > 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
+        const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, allRows.length)
+        const chunkKeys = await Promise.all(
+          allRows.slice(chunkStart, chunkEnd).map(row =>
+            Promise.all(plan.groupBy.map(expr => evaluateExpr({ node: expr, row, context })))
+          )
+        )
+        for (let j = 0; j < chunkKeys.length; j++) {
+          const key = keyify(...chunkKeys[j])
+          const row = allRows[chunkStart + j]
+          let group = groups.get(key)
+          if (!group) {
+            group = []
+            groups.set(key, group)
+          }
+          group.push(row)
         }
-        group.push(row)
       }
 
       /** @type {{ row: AsyncRow, rows: AsyncRow[], outputRow: AsyncRow }[]} */
@@ -166,8 +186,12 @@ export function executeScalarAggregate(plan, context) {
       // Collect all rows into single group
       /** @type {AsyncRow[]} */
       const group = []
+      let collectCount = 0
       for await (const row of child.rows()) {
-        if (context.signal?.aborted) return
+        if (++collectCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
         group.push(row)
       }
 

package/src/execute/execute.js

@@ -16,6 +16,9 @@ import { executeWindow } from './window.js'
  * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode, SetOperationNode, TableFunctionNode } from '../plan/types.js'
  */
 
+// Yield to the event loop every 4000 iterations so that aborts can actually fire
+const YIELD_INTERVAL = 4000
+
 /**
  * Executes a SQL SELECT query against tables
  *
@@ -406,12 +409,17 @@ async function* filterRows(rows, condition, context, limit) {
   let chunkSize = limit ?? 1
   const grow = limit !== undefined
   let rowIndex = 0
+  let innerCount = 0
 
   /** @type {{ row: AsyncRow, rowIndex: number }[]} */
   let buffer = []
 
   for await (const row of rows) {
     if (context.signal?.aborted) return
+    if (++innerCount % YIELD_INTERVAL === 0) {
+      await new Promise(resolve => setTimeout(resolve, 0))
+      if (context.signal?.aborted) return
+    }
     rowIndex++
     buffer.push({ row, rowIndex })
 
@@ -451,8 +459,13 @@ async function* limitRows(rows, limit = Infinity, offset = 0, signal) {
   if (limit <= 0) return
   let skipped = 0
   let yielded = 0
+  let innerCount = 0
   for await (const row of rows) {
     if (signal?.aborted) return
+    if (++innerCount % YIELD_INTERVAL === 0) {
+      await new Promise(resolve => setTimeout(resolve, 0))
+      if (signal?.aborted) return
+    }
     if (skipped < offset) {
       skipped++
       continue
@@ -500,16 +513,21 @@ function executeProject(plan, context) {
     maxRows: child.maxRows,
     async *rows() {
       let rowIndex = 0
+      let innerCount = 0
 
       for await (const row of child.rows()) {
         if (context.signal?.aborted) return
+        if (++innerCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
         rowIndex++
         const currentRowIndex = rowIndex
 
         /** @type {AsyncCells} */
         const cells = {}
         // Only safe to propagate resolved when every output column comes from
-        // the star branch — derived expressions evaluate lazily and can't be
+        // the star branch. Derived expressions evaluate lazily and can't be
         // pre-materialized here, and a partial resolved would make
         // collect()/downstream identifier fast paths read undefined.
         const source = resolveable ? row.resolved : undefined
@@ -588,9 +606,14 @@ function executeDistinct(plan, context) {
 
       /** @type {AsyncRow[]} */
       let buffer = []
+      let innerCount = 0
 
       for await (const row of child.rows()) {
         if (signal?.aborted) return
+        if (++innerCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (signal?.aborted) return
+        }
         buffer.push(row)
 
         if (buffer.length >= MAX_CHUNK) {
@@ -671,8 +694,13 @@ function executeSetOperation(plan, context) {
         async *rows() {
           // UNION: yield deduplicated rows from both sides
           const seen = new Set()
+          let count = 0
           for await (const row of left.rows()) {
             if (signal?.aborted) return
+            if (++count % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
               seen.add(key)
@@ -681,6 +709,10 @@ function executeSetOperation(plan, context) {
           }
           for await (const row of right.rows()) {
             if (signal?.aborted) return
+            if (++count % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
               seen.add(key)
@@ -700,8 +732,13 @@ function executeSetOperation(plan, context) {
         // Materialize right side keys
         /** @type {Map<any, number>} */
         const rightKeys = new Map()
+        let tick = 0
         for await (const row of right.rows()) {
           if (signal?.aborted) return
+          if (++tick % YIELD_INTERVAL === 0) {
+            await new Promise(resolve => setTimeout(resolve, 0))
+            if (signal?.aborted) return
+          }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
         }
@@ -710,6 +747,10 @@ function executeSetOperation(plan, context) {
           // INTERSECT ALL: yield each left row that matches, consuming right counts
           for await (const row of left.rows()) {
             if (signal?.aborted) return
+            if (++tick % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
             if (count) {
@@ -722,6 +763,10 @@ function executeSetOperation(plan, context) {
           const seen = new Set()
           for await (const row of left.rows()) {
             if (signal?.aborted) return
+            if (++tick % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (rightKeys.has(key) && !seen.has(key)) {
               seen.add(key)
@@ -742,8 +787,13 @@ function executeSetOperation(plan, context) {
         // Materialize right side keys
         /** @type {Map<any, number>} */
         const rightKeys = new Map()
+        let tick = 0
         for await (const row of right.rows()) {
           if (signal?.aborted) return
+          if (++tick % YIELD_INTERVAL === 0) {
+            await new Promise(resolve => setTimeout(resolve, 0))
+            if (signal?.aborted) return
+          }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
         }
@@ -752,6 +802,10 @@ function executeSetOperation(plan, context) {
           // EXCEPT ALL: yield left rows, consuming right counts
           for await (const row of left.rows()) {
             if (signal?.aborted) return
+            if (++tick % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
             if (count) {
@@ -765,6 +819,10 @@ function executeSetOperation(plan, context) {
           const seen = new Set()
           for await (const row of left.rows()) {
             if (signal?.aborted) return
+            if (++tick % YIELD_INTERVAL === 0) {
+              await new Promise(resolve => setTimeout(resolve, 0))
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!rightKeys.has(key) && !seen.has(key)) {
               seen.add(key)

package/src/execute/join.js

@@ -7,6 +7,9 @@ import { executePlan } from './execute.js'
  * @import { HashJoinNode, NestedLoopJoinNode, PositionalJoinNode } from '../plan/types.js'
  */
 
+// Yield to the event loop every 4000 iterations so that aborts can actually fire
+const YIELD_INTERVAL = 4000
+
 /**
  * Executes a nested loop join operation
  *
@@ -41,6 +44,7 @@ export function executeNestedLoopJoin(plan, context) {
       /** @type {Set<AsyncRow> | undefined} */
       const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
+      let innerCount = 0
       for await (const leftRow of left.rows()) {
         if (context.signal?.aborted) break
 
@@ -51,6 +55,10 @@ export function executeNestedLoopJoin(plan, context) {
         let hasMatch = false
 
         for (const rightRow of rightRows) {
+          if (++innerCount % YIELD_INTERVAL === 0) {
+            await new Promise(resolve => setTimeout(resolve, 0))
+            if (context.signal?.aborted) return
+          }
           const tempMerged = mergeRows(leftRow, rightRow, leftTable, rightTable)
           const matches = await evaluateExpr({
             node: plan.condition,
@@ -237,6 +245,7 @@ export function executeHashJoin(plan, context) {
       const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
       // Probe phase: stream left rows
+      let innerCount = 0
       for await (const leftRow of left.rows()) {
         if (context.signal?.aborted) break
 
@@ -253,6 +262,10 @@ export function executeHashJoin(plan, context) {
           const candidates = hashMap.get(key)
           if (candidates?.length) {
             for (const rightRow of candidates) {
+              if (++innerCount % YIELD_INTERVAL === 0) {
+                await new Promise(resolve => setTimeout(resolve, 0))
+                if (context.signal?.aborted) return
+              }
               const merged = mergeRows(leftRow, rightRow, leftTable, rightTable)
               if (residual) {
                 const ok = await evaluateExpr({ node: residual, row: merged, context })

package/src/execute/sort.js

@@ -59,7 +59,7 @@ export async function sortEntriesByTerms({ entries, orderBy, context, cacheValue
       let chunkSize = 1
       let start = 0
       while (start < missing.length) {
-        if (context.signal?.aborted) return []
+        context.signal?.throwIfAborted()
         const chunk = missing.slice(start, start + chunkSize)
         const values = await Promise.all(chunk.map(idx =>
           evaluateExpr({

package/src/execute/window.js

@@ -7,6 +7,9 @@ import { compareForTerm, keyify } from './utils.js'
  * @import { WindowNode, WindowSpec } from '../plan/types.js'
  */
 
+// Yield to the event loop every 4000 iterations so that aborts can actually fire
+const YIELD_INTERVAL = 4000
+
 /**
  * Executes a Window plan node: buffers the child's rows, assigns each window
  * function's output per partition, and yields rows in input order with the
@@ -36,8 +39,10 @@ export function executeWindow(plan, context) {
       async *rows() {
         let i = 0
         for await (const row of child.rows()) {
-          if (context.signal?.aborted) return
-          i++
+          if (++i % YIELD_INTERVAL === 0) {
+            await new Promise(resolve => setTimeout(resolve, 0))
+            if (context.signal?.aborted) return
+          }
           const cells = { ...row.cells }
           for (const w of plan.windows) {
             const value = i
@@ -59,8 +64,12 @@ export function executeWindow(plan, context) {
     async *rows() {
       /** @type {AsyncRow[]} */
       const rows = []
+      let collectCount = 0
       for await (const row of child.rows()) {
-        if (context.signal?.aborted) return
+        if (++collectCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
         rows.push(row)
       }
       if (rows.length === 0) return
@@ -74,8 +83,12 @@ export function executeWindow(plan, context) {
         if (context.signal?.aborted) return
       }
 
+      let emitCount = 0
       for (let i = 0; i < rows.length; i++) {
-        if (context.signal?.aborted) return
+        if (++emitCount % YIELD_INTERVAL === 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
         const row = rows[i]
         const cells = { ...row.cells }
         for (let w = 0; w < plan.windows.length; w++) {
@@ -105,17 +118,26 @@ async function computeWindow(spec, rows, output, context) {
   // Bucket row indices by partition key.
   /** @type {Map<string | number | bigint | boolean, number[]>} */
   const partitions = new Map()
-  const partitionKeys = await Promise.all(rows.map(row =>
-    Promise.all(spec.partitionBy.map(expr => evaluateExpr({ node: expr, row, context })))
-  ))
-  for (let i = 0; i < rows.length; i++) {
-    const key = keyify(...partitionKeys[i])
-    let bucket = partitions.get(key)
-    if (!bucket) {
-      bucket = []
-      partitions.set(key, bucket)
+  for (let chunkStart = 0; chunkStart < rows.length; chunkStart += YIELD_INTERVAL) {
+    if (chunkStart > 0) {
+      await new Promise(resolve => setTimeout(resolve, 0))
+      if (context.signal?.aborted) return
+    }
+    const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, rows.length)
+    const chunkKeys = await Promise.all(
+      rows.slice(chunkStart, chunkEnd).map(row =>
+        Promise.all(spec.partitionBy.map(expr => evaluateExpr({ node: expr, row, context })))
+      )
+    )
+    for (let j = 0; j < chunkKeys.length; j++) {
+      const key = keyify(...chunkKeys[j])
+      let bucket = partitions.get(key)
+      if (!bucket) {
+        bucket = []
+        partitions.set(key, bucket)
+      }
+      bucket.push(chunkStart + j)
     }
-    bucket.push(i)
   }
 
   for (const bucket of partitions.values()) {
@@ -125,11 +147,24 @@ async function computeWindow(spec, rows, output, context) {
     /** @type {number[]} */
     let ordered
     if (spec.orderBy.length) {
-      const orderValues = await Promise.all(bucket.map(idx =>
-        Promise.all(spec.orderBy.map(term => evaluateExpr({ node: term.expr, row: rows[idx], context })))
-      ))
       /** @type {{ idx: number, values: SqlPrimitive[], pos: number }[]} */
-      const entries = bucket.map((idx, k) => ({ idx, values: orderValues[k], pos: k }))
+      const entries = new Array(bucket.length)
+      for (let chunkStart = 0; chunkStart < bucket.length; chunkStart += YIELD_INTERVAL) {
+        if (chunkStart > 0) {
+          await new Promise(resolve => setTimeout(resolve, 0))
+          if (context.signal?.aborted) return
+        }
+        const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, bucket.length)
+        const chunkValues = await Promise.all(
+          bucket.slice(chunkStart, chunkEnd).map(idx =>
+            Promise.all(spec.orderBy.map(term => evaluateExpr({ node: term.expr, row: rows[idx], context })))
+          )
+        )
+        for (let j = 0; j < chunkValues.length; j++) {
+          const k = chunkStart + j
+          entries[k] = { idx: bucket[k], values: chunkValues[j], pos: k }
+        }
+      }
       entries.sort((a, b) => {
         for (let i = 0; i < spec.orderBy.length; i++) {
           const cmp = compareForTerm(a.values[i], b.values[i], spec.orderBy[i])
@@ -165,8 +200,12 @@ async function applyWindowFunction(spec, ordered, rows, output, context) {
   if (spec.funcName === 'LAG' || spec.funcName === 'LEAD') {
     const direction = spec.funcName === 'LAG' ? -1 : 1
     const [valueExpr, offsetExpr, defaultExpr] = spec.args
+    let tick = 0
     for (let k = 0; k < ordered.length; k++) {
-      if (context.signal?.aborted) return
+      if (++tick % YIELD_INTERVAL === 0) {
+        await new Promise(resolve => setTimeout(resolve, 0))
+        if (context.signal?.aborted) return
+      }
       const idx = ordered[k]
       const row = rows[idx]
       const offset = offsetExpr

package/src/expression/evaluate.js

@@ -16,6 +16,35 @@ import { evaluateStringFunc } from './strings.js'
  * @import { ExprNode, AsyncRow, ExecuteContext, SqlPrimitive } from '../types.js'
  */
 
+// Yield to the event loop every this many iterations so that aborts can actually fire
+const YIELD_INTERVAL = 4000
+
+/**
+ * Evaluates an expression for each row, yielding to the event loop every
+ * YIELD_INTERVAL rows so signal-based aborts can fire mid-evaluation.
+ *
+ * @param {ExprNode} node
+ * @param {AsyncRow[]} rows
+ * @param {ExecuteContext} context
+ * @returns {Promise<SqlPrimitive[]>}
+ */
+async function evaluateAll(node, rows, context) {
+  /** @type {SqlPrimitive[]} */
+  const results = new Array(rows.length)
+  for (let i = 0; i < rows.length; i += YIELD_INTERVAL) {
+    if (i > 0) {
+      await new Promise(resolve => setTimeout(resolve, 0))
+      context.signal?.throwIfAborted()
+    }
+    const end = Math.min(i + YIELD_INTERVAL, rows.length)
+    const chunk = await Promise.all(rows.slice(i, end).map(row =>
+      evaluateExpr({ node, row, context })
+    ))
+    for (let j = 0; j < chunk.length; j++) results[i + j] = chunk[j]
+  }
+  return results
+}
+
 /**
  * Evaluates an expression node against a row of data
  *
@@ -177,10 +206,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       // Apply FILTER clause if present
       let filteredRows = rows
       if (node.filter) {
-        const filterNode = node.filter
-        const passes = await Promise.all(rows.map(row =>
-          evaluateExpr({ node: filterNode, row, context })
-        ))
+        const passes = await evaluateAll(node.filter, rows, context)
         filteredRows = rows.filter((_, i) => passes[i])
       }
 
@@ -191,9 +217,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
           return filteredRows.length
         }
 
-        const values = await Promise.all(filteredRows.map(row =>
-          evaluateExpr({ node: argNode, row, context })
-        ))
+        const values = await evaluateAll(argNode, filteredRows, context)
         if (node.distinct) {
           const seen = new Set()
           for (const v of values) {
@@ -209,9 +233,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
 
       if (funcName === 'COUNTIF') {
-        const values = await Promise.all(filteredRows.map(row =>
-          evaluateExpr({ node: argNode, row, context })
-        ))
+        const values = await evaluateAll(argNode, filteredRows, context)
         let count = 0
         for (const v of values) {
           if (v) count++
@@ -220,9 +242,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
 
       if (funcName === 'SUM' || funcName === 'AVG' || funcName === 'MIN' || funcName === 'MAX') {
-        const rawValues = await Promise.all(filteredRows.map(row =>
-          evaluateExpr({ node: argNode, row, context })
-        ))
+        const rawValues = await evaluateAll(argNode, filteredRows, context)
         let sum = 0
         let count = 0
         /** @type {SqlPrimitive} */
@@ -247,9 +267,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
 
       if (funcName === 'STDDEV_SAMP' || funcName === 'STDDEV_POP') {
-        const rawValues = await Promise.all(filteredRows.map(row =>
-          evaluateExpr({ node: argNode, row, context })
-        ))
+        const rawValues = await evaluateAll(argNode, filteredRows, context)
         let sum = 0
         /** @type {number[]} */
         const values = []
@@ -290,9 +308,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
             ...node,
           })
         }
-        const rawValues = await Promise.all(filteredRows.map(row =>
-          evaluateExpr({ node: valueNode, row, context })
-        ))
+        const rawValues = await evaluateAll(valueNode, filteredRows, context)
         /** @type {number[]} */
         const values = []
         for (const raw of rawValues) {
@@ -311,12 +327,12 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
 
       if (funcName === 'JSON_ARRAYAGG' || funcName === 'ARRAY_AGG') {
+        const allValues = await evaluateAll(argNode, filteredRows, context)
         if (node.distinct) {
           /** @type {SqlPrimitive[]} */
           const values = []
           const seen = new Set()
-          for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, context })
+          for (const v of allValues) {
             const key = keyify(v)
             if (!seen.has(key)) {
               seen.add(key)
@@ -325,9 +341,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
           }
           return values
         } else {
-          return await Promise.all(filteredRows.map(row =>
-            evaluateExpr({ node: argNode, row, context })
-          ))
+          return allValues
         }
       }
 
@@ -336,10 +350,10 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         const separator = String(await evaluateExpr({ node: separatorNode, row: filteredRows[0] ?? { columns: [], cells: {} }, context }))
         /** @type {string[]} */
         const values = []
+        const allValues = await evaluateAll(argNode, filteredRows, context)
         if (node.distinct) {
           const seen = new Set()
-          for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, context })
+          for (const v of allValues) {
             if (v == null) continue
             const str = String(v)
             const key = keyify(str)
@@ -349,8 +363,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
             }
           }
         } else {
-          for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, context })
+          for (const v of allValues) {
             if (v != null) values.push(String(v))
           }
         }
@@ -687,7 +700,12 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   if (node.type === 'in') {
     const exprVal = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
     const subResult = executeStatement({ query: node.subquery, context })
+    let innerCount = 0
     for await (const resRow of subResult.rows()) {
+      if (++innerCount % YIELD_INTERVAL === 0) {
+        await new Promise(resolve => setTimeout(resolve, 0))
+        context.signal?.throwIfAborted()
+      }
       const value = await resRow.cells[resRow.columns[0]]()
       if (sqlEquals(exprVal, value)) return true
     }

package/src/parse/primary.js

@@ -40,7 +40,7 @@ export function parsePrimary(state) {
     return expr
   }
 
-  // Array literal: [elem, elem, ...] — elements must be literals
+  // Array literal: [elem, elem, ...] elements must be literals
   if (match(state, 'bracket', '[')) {
     /** @type {SqlPrimitive[]} */
     const values = []
@@ -158,7 +158,7 @@ export function parsePrimary(state) {
       prefix = name
       name = expect(state, 'identifier').value
     } else if (match(state, 'bracket', '[')) {
-      // table['column'] — string subscript is equivalent to dot access
+      // table['column'] string subscript is equivalent to dot access
       const fieldTok = current(state)
       if (fieldTok.type !== 'string') {
         throw parseError(state, 'string literal')