squirreling 0.12.6 → 0.12.7

package/package.json

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

package/src/execute/execute.js

@@ -448,11 +448,25 @@ function executeProject(plan, context) {
             // Common case: simple identifier. Avoid evaluateExpr overhead by
             // directly mapping to the child's cell, relying on the planner to
             // have normalized the identifier to match the child's column layout.
+            // If the identifier didn't normalize to a child cell key (e.g. the
+            // name refers to a table alias that produced no matching column),
+            // fall through to the evaluator so suffix-search and the proper
+            // ColumnNotFoundError apply instead of emitting an undefined cell.
             const id = col.expr
             const sourceName = id.prefix ? `${id.prefix}.${id.name}` : id.name
-            cells[columns[colIdx]] = row.cells[sourceName]
-            if (resolved && source) resolved[columns[colIdx]] = source[sourceName]
-            colIdx++
+            const alias = columns[colIdx++]
+            if (sourceName in row.cells) {
+              cells[alias] = row.cells[sourceName]
+              if (resolved && source) resolved[alias] = source[sourceName]
+            } else {
+              const { expr } = col
+              cells[alias] = () => evaluateExpr({
+                node: expr,
+                row,
+                rowIndex: currentRowIndex,
+                context,
+              })
+            }
           } else {
             const alias = columns[colIdx++]
             cells[alias] = () => evaluateExpr({

package/src/validation/aggregates.js

@@ -14,8 +14,13 @@ import { ParseError } from './parseErrors.js'
  */
 export function findAggregate(expr) {
   if (!expr) return undefined
-  if (expr.type === 'function' && isAggregateFunc(expr.funcName.toUpperCase())) {
-    return expr
+  if (expr.type === 'function') {
+    if (isAggregateFunc(expr.funcName.toUpperCase())) return expr
+    for (const arg of expr.args) {
+      const found = findAggregate(arg)
+      if (found) return found
+    }
+    return undefined
   }
   if (expr.type === 'binary') {
     return findAggregate(expr.left) || findAggregate(expr.right)