squirreling 0.16.7 → 0.16.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.16.7",
+  "version": "0.16.8",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,10 +40,10 @@
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@types/node": "26.6.2",
+    "@types/node": "26.6.3",
     "@vitest/coverage-v8": "5.0.2",
     "eslint": "10.11.0",
-    "eslint-plugin-jsdoc": "64.5.4",
+    "eslint-plugin-jsdoc": "65.0.0",
     "globals": "17.12.0",
     "typescript": "7.0.2",
     "vitest": "5.0.2"

package/src/backend/batch.js

@@ -125,6 +125,7 @@ export function selectVector(vector, selection) {
     throw new Error(`Cannot select ${selection.length} rows from vector length ${vector.length}`)
   }
   if (selection.type === 'all') return vector
+  if (vector.type === 'constant') return { ...vector, length: selectedRowCount(selection) }
   if (vector.type === 'selected') {
     const composed = composeSelections(vector.selection, selection)
     return {

package/src/execute/aggregates.js

@@ -309,6 +309,9 @@ function tryColumnScanAggregate(plan, { tables, signal }) {
     specs.push(spec)
   }
 
+  // Prepared batches can count selected rows without decoding a physical column.
+  if (table.prepareScan && specs.every(spec => spec.funcName === 'COUNT' && spec.star)) return
+
   const physicalColumns = new Set(specs.map(spec => spec.column))
   const hasPushdown = where || limit !== undefined || offset !== undefined
   if (hasPushdown) {

package/src/execute/batches.js

@@ -238,12 +238,16 @@ function projectedBatchColumn(batch, columnIndex) {
 /**
  * @param {ColumnVector} predicate
  * @param {number} rowCount
- * @returns {{ selection: Extract<RowSelection, { type: 'indices' }>, selectedCount: number }}
+ * @returns {{ selection: RowSelection, selectedCount: number }}
  */
 function predicateSelection(predicate, rowCount) {
   if (predicate.length !== rowCount) {
     throw new Error(`Predicate returned ${predicate.length} rows, expected ${rowCount}`)
   }
+  if (predicate.type === 'constant') {
+    const selectedCount = predicate.value ? rowCount : 0
+    return { selection: { type: 'range', start: 0, end: selectedCount, length: rowCount }, selectedCount }
+  }
   const indices = new Uint32Array(rowCount)
   let selectedCount = 0
   for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {

package/src/execute/streamingAggregate.js

@@ -523,6 +523,25 @@ async function accumulateBatch({ batch, inputs, specs, groups, context, rowOffse
     evaluateBatchInputs(inputs.args, batch, context, rowOffset),
   ])
   const rowCount = selectedRowCount(batch.selection)
+  context.signal?.throwIfAborted()
+  if (rowCount > 0 && keys.every(vector => vector?.type === 'constant') &&
+      specs.every(spec => spec.star && spec.funcName === 'COUNT' && !spec.node.distinct && !spec.node.filter)) {
+    const keyValues = keys.map(vector => valueAt(/** @type {ColumnVector} */ vector, 0))
+    const key = keyValues.length === 0
+      ? true
+      : keyValues.length === 1 ? keyify(keyValues[0]) : keyify(...keyValues)
+    let group = groups.get(key)
+    if (!group) {
+      group = {
+        firstRow: undefined,
+        keyValues,
+        accumulators: specs.map(spec => newAccumulator(spec.funcName, spec.node.distinct)),
+      }
+      groups.set(key, group)
+    }
+    for (const accumulator of group.accumulators) accumulator.count += rowCount
+    return
+  }
   for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
     if (rowIndex > 0 && rowIndex % CHUNK_SIZE === 0) {
       await yieldToEventLoop()

package/src/expression/batch.js

@@ -626,6 +626,13 @@ function resolveIdentifier(identifier, columns) {
  */
 function evaluateKernel(kernel, vectors, selection, signal, rowOffset = 0, rowOrdinals) {
   const length = selectedRowCount(selection)
+  // Supported kernels are deterministic; streamRowIndex only labels errors.
+  // Empty selections must not evaluate expressions (including invalid casts).
+  if (length > 0 && vectors.every(vector => vector.type === 'constant')) {
+    signal?.throwIfAborted()
+    const ordinal = rowOrdinals ? Number(valueAt(rowOrdinals, 0)) : 0
+    return { type: 'constant', value: kernel(vectors, 0, rowOffset + ordinal), length }
+  }
   if (signal && length > YIELD_INTERVAL) {
     return evaluateKernelAsync(kernel, vectors, length, signal, rowOffset, rowOrdinals)
   }