squirreling 0.12.21 → 0.12.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.21",
+  "version": "0.12.22",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/execute/aggregates.js

@@ -3,6 +3,7 @@ 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'
@@ -89,29 +90,45 @@ export function executeHashAggregate(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 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()
+      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 new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           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 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) {
@@ -189,7 +206,7 @@ export function executeScalarAggregate(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         group.push(row)

package/src/execute/execute.js

@@ -10,6 +10,7 @@ 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'
@@ -417,7 +418,7 @@ async function* filterRows(rows, condition, context, limit) {
   for await (const row of rows) {
     if (context.signal?.aborted) return
     if (++innerCount % YIELD_INTERVAL === 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (context.signal?.aborted) return
     }
     rowIndex++
@@ -463,7 +464,7 @@ async function* limitRows(rows, limit = Infinity, offset = 0, signal) {
   for await (const row of rows) {
     if (signal?.aborted) return
     if (++innerCount % YIELD_INTERVAL === 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (signal?.aborted) return
     }
     if (skipped < offset) {
@@ -518,7 +519,7 @@ function executeProject(plan, context) {
       for await (const row of child.rows()) {
         if (context.signal?.aborted) return
         if (++innerCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         rowIndex++
@@ -611,7 +612,7 @@ function executeDistinct(plan, context) {
       for await (const row of child.rows()) {
         if (signal?.aborted) return
         if (++innerCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (signal?.aborted) return
         }
         buffer.push(row)
@@ -698,7 +699,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++count % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -710,7 +711,7 @@ 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))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -736,7 +737,7 @@ function executeSetOperation(plan, context) {
         for await (const row of right.rows()) {
           if (signal?.aborted) return
           if (++tick % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (signal?.aborted) return
           }
           const key = await stableRowKey(row)
@@ -748,7 +749,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -764,7 +765,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -791,7 +792,7 @@ function executeSetOperation(plan, context) {
         for await (const row of right.rows()) {
           if (signal?.aborted) return
           if (++tick % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (signal?.aborted) return
           }
           const key = await stableRowKey(row)
@@ -803,7 +804,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)
@@ -820,7 +821,7 @@ function executeSetOperation(plan, context) {
           for await (const row of left.rows()) {
             if (signal?.aborted) return
             if (++tick % YIELD_INTERVAL === 0) {
-              await new Promise(resolve => setTimeout(resolve, 0))
+              await yieldToEventLoop()
               if (signal?.aborted) return
             }
             const key = await stableRowKey(row)

package/src/execute/join.js

@@ -1,6 +1,7 @@
 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'
@@ -56,7 +57,7 @@ export function executeNestedLoopJoin(plan, context) {
 
         for (const rightRow of rightRows) {
           if (++innerCount % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (context.signal?.aborted) return
           }
           const tempMerged = mergeRows(leftRow, rightRow, leftTable, rightTable)
@@ -263,7 +264,7 @@ export function executeHashJoin(plan, context) {
           if (candidates?.length) {
             for (const rightRow of candidates) {
               if (++innerCount % YIELD_INTERVAL === 0) {
-                await new Promise(resolve => setTimeout(resolve, 0))
+                await yieldToEventLoop()
                 if (context.signal?.aborted) return
               }
               const merged = mergeRows(leftRow, rightRow, leftTable, rightTable)

package/src/execute/window.js

@@ -1,6 +1,7 @@
 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'
@@ -40,7 +41,7 @@ export function executeWindow(plan, context) {
         let i = 0
         for await (const row of child.rows()) {
           if (++i % YIELD_INTERVAL === 0) {
-            await new Promise(resolve => setTimeout(resolve, 0))
+            await yieldToEventLoop()
             if (context.signal?.aborted) return
           }
           const cells = { ...row.cells }
@@ -67,7 +68,7 @@ export function executeWindow(plan, context) {
       let collectCount = 0
       for await (const row of child.rows()) {
         if (++collectCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         rows.push(row)
@@ -86,7 +87,7 @@ export function executeWindow(plan, context) {
       let emitCount = 0
       for (let i = 0; i < rows.length; i++) {
         if (++emitCount % YIELD_INTERVAL === 0) {
-          await new Promise(resolve => setTimeout(resolve, 0))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         const row = rows[i]
@@ -120,7 +121,7 @@ async function computeWindow(spec, rows, output, context) {
   const partitions = new Map()
   for (let chunkStart = 0; chunkStart < rows.length; chunkStart += YIELD_INTERVAL) {
     if (chunkStart > 0) {
-      await new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       if (context.signal?.aborted) return
     }
     const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, rows.length)
@@ -151,7 +152,7 @@ async function computeWindow(spec, rows, output, context) {
       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))
+          await yieldToEventLoop()
           if (context.signal?.aborted) return
         }
         const chunkEnd = Math.min(chunkStart + YIELD_INTERVAL, bucket.length)
@@ -203,7 +204,7 @@ async function applyWindowFunction(spec, ordered, rows, output, context) {
     let tick = 0
     for (let k = 0; k < ordered.length; k++) {
       if (++tick % YIELD_INTERVAL === 0) {
-        await new Promise(resolve => setTimeout(resolve, 0))
+        await yieldToEventLoop()
         if (context.signal?.aborted) return
       }
       const idx = ordered[k]

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'
@@ -31,16 +32,21 @@ const YIELD_INTERVAL = 4000
 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 new Promise(resolve => setTimeout(resolve, 0))
+      await yieldToEventLoop()
       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]
+    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
 }
@@ -703,7 +709,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     let innerCount = 0
     for await (const resRow of subResult.rows()) {
       if (++innerCount % YIELD_INTERVAL === 0) {
-        await new Promise(resolve => setTimeout(resolve, 0))
+        await yieldToEventLoop()
         context.signal?.throwIfAborted()
       }
       const value = await resRow.cells[resRow.columns[0]]()