squirreling 0.12.20 → 0.12.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.20",
+  "version": "0.12.22",
   "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

@@ -3,12 +3,16 @@ import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan, selectColumnNames } from './execute.js'
 import { sortEntriesByTerms } from './sort.js'
 import { keyify } from './utils.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, QueryResults, SelectColumn, SqlPrimitive } from '../types.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,23 +87,56 @@ 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 yieldToEventLoop()
+          if (context.signal?.aborted) return
+        }
         allRows.push(row)
       }
 
-      // Group rows by GROUP BY keys
+      // Group rows by GROUP BY keys.
+      // Each chunk dispatches all per-row key evaluations in parallel so
+      // async cells (e.g. lazy parquet decode) overlap; the await is at the
+      // chunk boundary. Synchronous cells stay cheap because we skip the
+      // inner Promise.all wrapper when there's a single GROUP BY expression.
       /** @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)
+      const { groupBy } = plan
+      const singleKey = groupBy.length === 1
+      const singleExpr = singleKey ? groupBy[0] : null
+
+      for (let chunkStart = 0; chunkStart < allRows.length; chunkStart += YIELD_INTERVAL) {
+        if (chunkStart > 0) {
+          await yieldToEventLoop()
+          if (context.signal?.aborted) return
+        }
+        const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, allRows.length)
+        const chunkLen = chunkEnd - chunkStart
+        /** @type {Promise<any>[]} */
+        const pending = new Array(chunkLen)
+        if (singleKey) {
+          for (let j = 0; j < chunkLen; j++) {
+            pending[j] = evaluateExpr({ node: singleExpr, row: allRows[chunkStart + j], context })
+          }
+        } else {
+          for (let j = 0; j < chunkLen; j++) {
+            const row = allRows[chunkStart + j]
+            pending[j] = Promise.all(groupBy.map(expr => evaluateExpr({ node: expr, row, context })))
+          }
+        }
+        const chunkKeys = await Promise.all(pending)
+        for (let j = 0; j < chunkLen; j++) {
+          const key = singleKey ? keyify(chunkKeys[j]) : 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 +203,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 yieldToEventLoop()
+          if (context.signal?.aborted) return
+        }
         group.push(row)
       }
 

package/src/execute/execute.js

@@ -10,12 +10,16 @@ import { executeHashJoin, executeNestedLoopJoin, executePositionalJoin } from '.
 import { executeSort } from './sort.js'
 import { addBounds, minBounds, stableRowKey } from './utils.js'
 import { executeWindow } from './window.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncDataSource, AsyncRow, DerivedColumn, ExecuteContext, ExecuteSqlOptions, ExprNode, IdentifierNode, QueryResults, SelectColumn, SqlPrimitive, Statement } from '../types.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 +410,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 yieldToEventLoop()
+      if (context.signal?.aborted) return
+    }
     rowIndex++
     buffer.push({ row, rowIndex })
 
@@ -451,8 +460,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 yieldToEventLoop()
+      if (signal?.aborted) return
+    }
     if (skipped < offset) {
       skipped++
       continue
@@ -500,16 +514,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 yieldToEventLoop()
+          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 +607,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 yieldToEventLoop()
+          if (signal?.aborted) return
+        }
         buffer.push(row)
 
         if (buffer.length >= MAX_CHUNK) {
@@ -671,8 +695,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 yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
               seen.add(key)
@@ -681,6 +710,10 @@ function executeSetOperation(plan, context) {
           }
           for await (const row of right.rows()) {
             if (signal?.aborted) return
+            if (++count % YIELD_INTERVAL === 0) {
+              await yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!seen.has(key)) {
               seen.add(key)
@@ -700,8 +733,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 yieldToEventLoop()
+            if (signal?.aborted) return
+          }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
         }
@@ -710,6 +748,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 yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
             if (count) {
@@ -722,6 +764,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 yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (rightKeys.has(key) && !seen.has(key)) {
               seen.add(key)
@@ -742,8 +788,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 yieldToEventLoop()
+            if (signal?.aborted) return
+          }
           const key = await stableRowKey(row)
           rightKeys.set(key, (rightKeys.get(key) ?? 0) + 1)
         }
@@ -752,6 +803,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 yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             const count = rightKeys.get(key)
             if (count) {
@@ -765,6 +820,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 yieldToEventLoop()
+              if (signal?.aborted) return
+            }
             const key = await stableRowKey(row)
             if (!rightKeys.has(key) && !seen.has(key)) {
               seen.add(key)

package/src/execute/join.js

@@ -1,12 +1,16 @@
 import { evaluateExpr } from '../expression/evaluate.js'
 import { keyify, maxBounds } from './utils.js'
 import { executePlan } from './execute.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncCells, AsyncRow, ExecuteContext, QueryResults } from '../types.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 +45,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 +56,10 @@ export function executeNestedLoopJoin(plan, context) {
         let hasMatch = false
 
         for (const rightRow of rightRows) {
+          if (++innerCount % YIELD_INTERVAL === 0) {
+            await yieldToEventLoop()
+            if (context.signal?.aborted) return
+          }
           const tempMerged = mergeRows(leftRow, rightRow, leftTable, rightTable)
           const matches = await evaluateExpr({
             node: plan.condition,
@@ -237,6 +246,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 +263,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 yieldToEventLoop()
+                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

@@ -1,12 +1,16 @@
 import { evaluateExpr } from '../expression/evaluate.js'
 import { executePlan } from './execute.js'
 import { compareForTerm, keyify } from './utils.js'
+import { yieldToEventLoop } from './yield.js'
 
 /**
  * @import { AsyncRow, ExecuteContext, QueryResults, SqlPrimitive } from '../types.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 +40,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 yieldToEventLoop()
+            if (context.signal?.aborted) return
+          }
           const cells = { ...row.cells }
           for (const w of plan.windows) {
             const value = i
@@ -59,8 +65,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 yieldToEventLoop()
+          if (context.signal?.aborted) return
+        }
         rows.push(row)
       }
       if (rows.length === 0) return
@@ -74,8 +84,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 yieldToEventLoop()
+          if (context.signal?.aborted) return
+        }
         const row = rows[i]
         const cells = { ...row.cells }
         for (let w = 0; w < plan.windows.length; w++) {
@@ -105,17 +119,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 yieldToEventLoop()
+      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 +148,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 yieldToEventLoop()
+          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 +201,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 yieldToEventLoop()
+        if (context.signal?.aborted) return
+      }
       const idx = ordered[k]
       const row = rows[idx]
       const offset = offsetExpr

package/src/execute/yield.js

@@ -0,0 +1,30 @@
+// Yield to the event loop so that timer-based aborts can fire.
+//
+// In Node, setTimeout(fn, 0) is clamped to a 1ms minimum, so a tight loop
+// that yields every few thousand iterations can spend hundreds of ms in
+// scheduling overhead alone. setImmediate (Node) and MessageChannel
+// (browsers) provide the same macrotask boundary at a fraction of the cost.
+//
+// We need a macrotask boundary (not just a microtask) because the abort
+// timer itself is a macrotask; microtasks alone cannot let it fire.
+
+/** @type {() => Promise<void>} */
+export const yieldToEventLoop = (() => {
+  if (typeof setImmediate === 'function') {
+    return () => new Promise(resolve => setImmediate(resolve))
+  }
+  if (typeof MessageChannel !== 'undefined') {
+    const channel = new MessageChannel()
+    /** @type {Array<() => void>} */
+    const queue = []
+    channel.port1.onmessage = () => {
+      const resolve = queue.shift()
+      if (resolve) resolve()
+    }
+    return () => new Promise(resolve => {
+      queue.push(resolve)
+      channel.port2.postMessage(0)
+    })
+  }
+  return () => new Promise(resolve => setTimeout(resolve, 0))
+})()

package/src/expression/evaluate.js

@@ -1,5 +1,6 @@
 import { executeStatement } from '../execute/execute.js'
 import { isPlainObject, keyify, sqlEquals, stringify } from '../execute/utils.js'
+import { yieldToEventLoop } from '../execute/yield.js'
 import { ArgValueError, ExecutionError } from '../validation/executionErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation/functions.js'
 import { UnknownFunctionError } from '../validation/parseErrors.js'
@@ -16,6 +17,40 @@ 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)
+  /** @type {Promise<SqlPrimitive>[]} */
+  const pending = new Array(Math.min(YIELD_INTERVAL, rows.length))
+  for (let i = 0; i < rows.length; i += YIELD_INTERVAL) {
+    if (i > 0) {
+      await yieldToEventLoop()
+      context.signal?.throwIfAborted()
+    }
+    const end = Math.min(i + YIELD_INTERVAL, rows.length)
+    const chunkLen = end - i
+    pending.length = chunkLen
+    for (let j = 0; j < chunkLen; j++) {
+      pending[j] = evaluateExpr({ node, row: rows[i + j], context })
+    }
+    const chunk = await Promise.all(pending)
+    for (let j = 0; j < chunkLen; j++) results[i + j] = chunk[j]
+  }
+  return results
+}
+
 /**
  * Evaluates an expression node against a row of data
  *
@@ -177,10 +212,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 +223,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 +239,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 +248,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 +273,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 +314,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 +333,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 +347,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 +356,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 +369,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 +706,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 yieldToEventLoop()
+        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')