squirreling 0.6.0 → 0.7.0

package/src/execute/expression.js

@@ -1,18 +1,18 @@
 import { unknownFunctionError } from '../parseErrors.js'
 import { invalidContextError } from '../executionErrors.js'
 import {
-  argCountError,
+  aggregateError,
   argValueError,
   castError,
 } from '../validationErrors.js'
-import { isMathFunc } from '../validation.js'
+import { isAggregateFunc, isMathFunc } from '../validation.js'
 import { applyIntervalToDate } from './date.js'
 import { executeSelect } from './execute.js'
 import { evaluateMathFunc } from './math.js'
 import { applyBinaryOp, stringify } from './utils.js'
 
 /**
- * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, IntervalUnit } from '../types.js'
+ * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, IntervalUnit, UserDefinedFunction } from '../types.js'
  */
 
 /**
@@ -22,10 +22,12 @@ import { applyBinaryOp, stringify } from './utils.js'
  * @param {ExprNode} params.node - The expression node to evaluate
  * @param {AsyncRow} params.row - The data row to evaluate against
  * @param {Record<string, AsyncDataSource>} params.tables
+ * @param {Record<string, UserDefinedFunction>} [params.functions] - User-defined functions
  * @param {number} [params.rowIndex] - 1-based row index for error reporting
+ * @param {AsyncRow[]} [params.rows] - Group of rows for aggregate functions
  * @returns {Promise<SqlPrimitive>} The result of the evaluation
  */
-export async function evaluateExpr({ node, row, tables, rowIndex }) {
+export async function evaluateExpr({ node, row, tables, functions, rowIndex, rows }) {
   if (node.type === 'literal') {
     return node.value
   }
@@ -47,7 +49,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
 
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
-    const gen = executeSelect(node.subquery, tables)
+    const gen = executeSelect({ select: node.subquery, tables })
     const { value } = await gen.next() // Start the generator
     gen.return(undefined) // Stop further execution
     if (!value) return null
@@ -57,16 +59,16 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
   // Unary operators
   if (node.type === 'unary') {
     if (node.op === 'NOT') {
-      return !await evaluateExpr({ node: node.argument, row, tables, rowIndex })
+      return !await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows })
     }
     if (node.op === 'IS NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables, rowIndex }) == null
+      return await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows }) == null
     }
     if (node.op === 'IS NOT NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables, rowIndex }) != null
+      return await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows }) != null
     }
     if (node.op === '-') {
-      const val = await evaluateExpr({ node: node.argument, row, tables, rowIndex })
+      const val = await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows })
       if (val == null) return null
       return -val
     }
@@ -76,15 +78,15 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
   if (node.type === 'binary') {
     // Handle date +/- interval at AST level
     if ((node.op === '+' || node.op === '-') && node.right.type === 'interval') {
-      const dateVal = await evaluateExpr({ node: node.left, row, tables, rowIndex })
+      const dateVal = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows })
       return applyIntervalToDate(dateVal, node.right.value, node.right.unit, node.op)
     }
     if (node.op === '+' && node.left.type === 'interval') {
-      const dateVal = await evaluateExpr({ node: node.right, row, tables, rowIndex })
+      const dateVal = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows })
       return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
     }
 
-    const left = await evaluateExpr({ node: node.left, row, tables, rowIndex })
+    const left = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows })
 
     // Short-circuit evaluation for AND and OR
     if (node.op === 'AND') {
@@ -94,59 +96,123 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
       if (left) return true
     }
 
-    const right = await evaluateExpr({ node: node.right, row, tables, rowIndex })
+    const right = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows })
     return applyBinaryOp(node.op, left, right)
   }
 
   // Function calls
   if (node.type === 'function') {
     const funcName = node.name.toUpperCase()
-    /** @type {SqlPrimitive[]} */
-    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, rowIndex })))
 
-    if (funcName === 'UPPER') {
-      if (args.length !== 1) {
-        throw argCountError({
-          funcName: 'UPPER',
-          expected: 1,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
+    // Handle aggregate functions
+    if (isAggregateFunc(funcName)) {
+      if (!rows) {
+        throw aggregateError({
+          funcName,
+          issue: 'requires GROUP BY or will act on the whole dataset',
         })
       }
+
+      // Check for star argument (COUNT(*))
+      if (node.args.length === 1 && node.args[0].type === 'identifier' && node.args[0].name === '*') {
+        if (funcName === 'COUNT') {
+          return rows.length
+        }
+        throw aggregateError({
+          funcName,
+          issue: '(*) is not supported, use a column name',
+        })
+      }
+
+      const argNode = node.args[0]
+
+      if (funcName === 'COUNT') {
+        if (node.distinct) {
+          const seen = new Set()
+          for (const r of rows) {
+            const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
+            if (v != null) seen.add(v)
+          }
+          return seen.size
+        }
+        let count = 0
+        for (const r of rows) {
+          const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
+          if (v != null) count++
+        }
+        return count
+      }
+
+      if (funcName === 'SUM' || funcName === 'AVG' || funcName === 'MIN' || funcName === 'MAX') {
+        let sum = 0
+        let count = 0
+        /** @type {number | null} */
+        let min = null
+        /** @type {number | null} */
+        let max = null
+
+        for (const r of rows) {
+          const raw = await evaluateExpr({ node: argNode, row: r, tables, functions })
+          if (raw == null) continue
+          const num = Number(raw)
+          if (!Number.isFinite(num)) continue
+
+          if (count === 0) {
+            min = num
+            max = num
+          } else {
+            if (min == null || num < min) min = num
+            if (max == null || num > max) max = num
+          }
+          sum += num
+          count++
+        }
+
+        if (funcName === 'SUM') return sum
+        if (funcName === 'AVG') return count === 0 ? null : sum / count
+        if (funcName === 'MIN') return min
+        if (funcName === 'MAX') return max
+      }
+
+      if (funcName === 'JSON_ARRAYAGG') {
+        /** @type {SqlPrimitive[]} */
+        const values = []
+        if (node.distinct) {
+          const seen = new Set()
+          for (const r of rows) {
+            const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
+            const key = stringify(v)
+            if (!seen.has(key)) {
+              seen.add(key)
+              values.push(v)
+            }
+          }
+        } else {
+          for (const r of rows) {
+            const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
+            values.push(v)
+          }
+        }
+        return values
+      }
+    }
+
+    /** @type {SqlPrimitive[]} */
+    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows })))
+
+    if (funcName === 'UPPER') {
       const val = args[0]
       if (val == null) return null
       return String(val).toUpperCase()
     }
 
     if (funcName === 'LOWER') {
-      if (args.length !== 1) {
-        throw argCountError({
-          funcName: 'LOWER',
-          expected: 1,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       const val = args[0]
       if (val == null) return null
       return String(val).toLowerCase()
     }
 
     if (funcName === 'CONCAT') {
-      if (args.length < 1) {
-        throw argCountError({
-          funcName: 'CONCAT',
-          expected: 'at least 1',
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       // SQL CONCAT returns NULL if any argument is NULL
       if (args.some(a => a == null)) return null
       if (args.some(a => typeof a === 'object')) {
@@ -163,32 +229,12 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
     }
 
     if (funcName === 'LENGTH') {
-      if (args.length !== 1) {
-        throw argCountError({
-          funcName: 'LENGTH',
-          expected: 1,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       const val = args[0]
       if (val == null) return null
       return String(val).length
     }
 
     if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
-      if (args.length < 2 || args.length > 3) {
-        throw argCountError({
-          funcName,
-          expected: '2 or 3',
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       const str = args[0]
       if (str == null) return null
       const strVal = String(str)
@@ -222,32 +268,12 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
     }
 
     if (funcName === 'TRIM') {
-      if (args.length !== 1) {
-        throw argCountError({
-          funcName: 'TRIM',
-          expected: 1,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       const val = args[0]
       if (val == null) return null
       return String(val).trim()
     }
 
     if (funcName === 'REPLACE') {
-      if (args.length !== 3) {
-        throw argCountError({
-          funcName: 'REPLACE',
-          expected: 3,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       const str = args[0]
       const searchStr = args[1]
       const replaceStr = args[2]
@@ -257,67 +283,26 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
     }
 
     if (funcName === 'RANDOM' || funcName === 'RAND') {
-      if (args.length !== 0) {
-        throw argCountError({
-          funcName,
-          expected: 0,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       return Math.random()
     }
 
     if (funcName === 'CURRENT_DATE') {
-      if (args.length !== 0) {
-        throw argCountError({
-          funcName: 'CURRENT_DATE',
-          expected: 0,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       return new Date().toISOString().split('T')[0]
     }
 
     if (funcName === 'CURRENT_TIME') {
-      if (args.length !== 0) {
-        throw argCountError({
-          funcName: 'CURRENT_TIME',
-          expected: 0,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       return new Date().toISOString().split('T')[1].replace('Z', '')
     }
 
     if (funcName === 'CURRENT_TIMESTAMP') {
-      if (args.length !== 0) {
-        throw argCountError({
-          funcName: 'CURRENT_TIMESTAMP',
-          expected: 0,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       return new Date().toISOString()
     }
 
     if (funcName === 'JSON_OBJECT') {
       if (args.length % 2 !== 0) {
-        throw argCountError({
+        throw argValueError({
           funcName: 'JSON_OBJECT',
-          expected: 'even number',
-          received: args.length,
+          message: 'requires an even number of arguments (key-value pairs)',
           positionStart: node.positionStart,
           positionEnd: node.positionEnd,
           rowNumber: rowIndex,
@@ -344,16 +329,6 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
     }
 
     if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
-      if (args.length !== 2) {
-        throw argCountError({
-          funcName,
-          expected: 2,
-          received: args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
       let jsonArg = args[0]
       const pathArg = args[1]
       if (jsonArg == null || pathArg == null) return null
@@ -410,13 +385,15 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
     }
 
     if (isMathFunc(funcName)) {
-      return evaluateMathFunc({
-        funcName,
-        args,
-        positionStart: node.positionStart,
-        positionEnd: node.positionEnd,
-        rowNumber: rowIndex,
-      })
+      return evaluateMathFunc({ funcName, args })
+    }
+
+    // Check user-defined functions (case-insensitive lookup)
+    if (functions) {
+      const udfName = Object.keys(functions).find(k => k.toUpperCase() === funcName)
+      if (udfName) {
+        return await functions[udfName](...args)
+      }
     }
 
     throw unknownFunctionError({
@@ -427,7 +404,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
   }
 
   if (node.type === 'cast') {
-    const val = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
+    const val = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
     if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
@@ -470,17 +447,17 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
 
   // IN and NOT IN with value lists
   if (node.type === 'in valuelist') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
     for (const valueNode of node.values) {
-      const val = await evaluateExpr({ node: valueNode, row, tables, rowIndex })
+      const val = await evaluateExpr({ node: valueNode, row, tables, functions, rowIndex, rows })
       if (exprVal === val) return true
     }
     return false
   }
   // IN with subqueries
   if (node.type === 'in') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
-    const results = executeSelect(node.subquery, tables)
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
+    const results = executeSelect({ select: node.subquery, tables })
     for await (const resRow of results) {
       const value = await resRow.cells[resRow.columns[0]]()
       if (exprVal === value) return true
@@ -490,39 +467,39 @@ export async function evaluateExpr({ node, row, tables, rowIndex }) {
 
   // EXISTS and NOT EXISTS with subqueries
   if (node.type === 'exists') {
-    const results = await executeSelect(node.subquery, tables).next()
+    const results = await executeSelect({ select: node.subquery, tables }).next()
     return results.done === false
   }
   if (node.type === 'not exists') {
-    const results = await executeSelect(node.subquery, tables).next()
+    const results = await executeSelect({ select: node.subquery, tables }).next()
     return results.done === true
   }
 
   // CASE expressions
   if (node.type === 'case') {
     // For simple CASE: evaluate the case expression once
-    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, tables, rowIndex })
+    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, tables, functions, rowIndex, rows })
 
     // Iterate through WHEN clauses
     for (const whenClause of node.whenClauses) {
       let conditionResult
       if (caseValue !== undefined) {
         // Simple CASE: compare caseValue with condition
-        const whenValue = await evaluateExpr({ node: whenClause.condition, row, tables, rowIndex })
+        const whenValue = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows })
         conditionResult = caseValue === whenValue
       } else {
         // Searched CASE: evaluate condition as boolean
-        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, rowIndex })
+        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows })
       }
 
       if (conditionResult) {
-        return evaluateExpr({ node: whenClause.result, row, tables, rowIndex })
+        return evaluateExpr({ node: whenClause.result, row, tables, functions, rowIndex, rows })
       }
     }
 
     // No WHEN clause matched, return ELSE result or NULL
     if (node.elseResult) {
-      return evaluateExpr({ node: node.elseResult, row, tables, rowIndex })
+      return evaluateExpr({ node: node.elseResult, row, tables, functions, rowIndex, rows })
     }
     return null
   }

package/src/execute/having.js

@@ -4,19 +4,21 @@ import { evaluateExpr } from './expression.js'
 import { applyBinaryOp } from './utils.js'
 
 /**
- * @import { AggregateFunc, AsyncDataSource, ExprNode, AsyncRow, SqlPrimitive } from '../types.js'
+ * @import { AggregateFunc, AsyncDataSource, ExprNode, AsyncRow, SqlPrimitive, UserDefinedFunction } from '../types.js'
  */
 
 /**
  * Evaluates a HAVING expression with support for aggregate functions
  *
- * @param {ExprNode} expr - the HAVING expression
- * @param {AsyncRow} row - the aggregated result row
- * @param {AsyncRow[]} group - the group of rows for re-evaluating aggregates
- * @param {Record<string, AsyncDataSource>} tables
+ * @param {Object} options
+ * @param {ExprNode} options.expr - the HAVING expression
+ * @param {AsyncRow} options.row - the aggregated result row
+ * @param {AsyncRow[]} options.group - the group of rows for re-evaluating aggregates
+ * @param {Record<string, AsyncDataSource>} options.tables
+ * @param {Record<string, UserDefinedFunction>} [options.functions]
  * @returns {Promise<boolean>} whether the HAVING condition is satisfied
  */
-export async function evaluateHavingExpr(expr, row, group, tables) {
+export async function evaluateHavingExpr({ expr, row, group, tables, functions }) {
   // Having context
   const context = { ...group[0] ?? {}, ...row }
 
@@ -26,12 +28,12 @@ export async function evaluateHavingExpr(expr, row, group, tables) {
     const funcName = expr.name.toUpperCase()
     if (isAggregateFunc(funcName)) {
       // Evaluate aggregate function on the group
-      return Boolean(await evaluateAggregateFunction(funcName, expr.args, group, tables))
+      return Boolean(await evaluateAggregateFunction({ funcName, args: expr.args, group, tables, functions }))
     }
   }
 
   if (expr.type === 'binary') {
-    const left = await evaluateHavingValue(expr.left, context, group, tables)
+    const left = await evaluateHavingValue({ expr: expr.left, context, group, tables, functions })
 
     // Short-circuit evaluation for AND and OR
     if (expr.op === 'AND') {
@@ -41,61 +43,65 @@ export async function evaluateHavingExpr(expr, row, group, tables) {
       if (left) return true
     }
 
-    const right = await evaluateHavingValue(expr.right, context, group, tables)
+    const right = await evaluateHavingValue({ expr: expr.right, context, group, tables, functions })
     return Boolean(applyBinaryOp(expr.op, left, right))
   }
 
   if (expr.type === 'unary') {
     if (expr.op === 'NOT') {
-      return !await evaluateHavingExpr(expr.argument, context, group, tables)
+      return !await evaluateHavingExpr({ expr: expr.argument, row: context, group, tables, functions })
     }
     if (expr.op === 'IS NULL') {
-      return await evaluateHavingValue(expr.argument, context, group, tables) == null
+      return await evaluateHavingValue({ expr: expr.argument, context, group, tables, functions }) == null
     }
     if (expr.op === 'IS NOT NULL') {
-      return await evaluateHavingValue(expr.argument, context, group, tables) != null
+      return await evaluateHavingValue({ expr: expr.argument, context, group, tables, functions }) != null
     }
   }
 
   // For other expression types, use the context row
-  return Boolean(await evaluateExpr({ node: expr, row: context, tables }))
+  return Boolean(await evaluateExpr({ node: expr, row: context, tables, functions }))
 }
 
 /**
  * Evaluates a value in a HAVING expression
  *
- * @param {ExprNode} expr
- * @param {AsyncRow} context - the context row
- * @param {AsyncRow[]} group - the group of rows
- * @param {Record<string, AsyncDataSource>} tables
+ * @param {Object} options
+ * @param {ExprNode} options.expr
+ * @param {AsyncRow} options.context - the context row
+ * @param {AsyncRow[]} options.group - the group of rows
+ * @param {Record<string, AsyncDataSource>} options.tables
+ * @param {Record<string, UserDefinedFunction>} [options.functions]
  * @returns {Promise<SqlPrimitive>} the evaluated value
  */
-function evaluateHavingValue(expr, context, group, tables) {
+function evaluateHavingValue({ expr, context, group, tables, functions }) {
   if (expr.type === 'function') {
     const funcName = expr.name.toUpperCase()
     if (isAggregateFunc(funcName)) {
-      return evaluateAggregateFunction(funcName, expr.args, group, tables)
+      return evaluateAggregateFunction({ funcName, args: expr.args, group, tables, functions })
     }
   }
 
   // For binary expressions, we need to use evaluateHavingExpr to properly handle aggregates
   if (expr.type === 'binary' || expr.type === 'unary') {
-    return evaluateHavingExpr(expr, context, group, tables)
+    return evaluateHavingExpr({ expr, row: context, group, tables, functions })
   }
 
-  return evaluateExpr({ node: expr, row: context, tables })
+  return evaluateExpr({ node: expr, row: context, tables, functions })
 }
 
 /**
  * Evaluates an aggregate function on a group
  *
- * @param {AggregateFunc} funcName - aggregate function name
- * @param {ExprNode[]} args - function arguments
- * @param {AsyncRow[]} group - the group of rows
- * @param {Record<string, AsyncDataSource>} tables
+ * @param {Object} options
+ * @param {AggregateFunc} options.funcName - aggregate function name
+ * @param {ExprNode[]} options.args - function arguments
+ * @param {AsyncRow[]} options.group - the group of rows
+ * @param {Record<string, AsyncDataSource>} options.tables
+ * @param {Record<string, UserDefinedFunction>} [options.functions]
  * @returns {Promise<SqlPrimitive>} the aggregate result
  */
-async function evaluateAggregateFunction(funcName, args, group, tables) {
+async function evaluateAggregateFunction({ funcName, args, group, tables, functions }) {
   if (funcName === 'COUNT') {
     if (args.length === 1 && args[0].type === 'identifier' && args[0].name === '*') {
       return group.length
@@ -103,7 +109,7 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
     // COUNT(column) - count non-null values
     let count = 0
     for (const row of group) {
-      const val = await evaluateExpr({ node: args[0], row, tables })
+      const val = await evaluateExpr({ node: args[0], row, tables, functions })
       if (val != null) count++
     }
     return count
@@ -112,7 +118,7 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
   if (funcName === 'SUM') {
     let sum = 0
     for (const row of group) {
-      const val = await evaluateExpr({ node: args[0], row, tables })
+      const val = await evaluateExpr({ node: args[0], row, tables, functions })
       if (val != null) sum += Number(val)
     }
     return sum
@@ -122,7 +128,7 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
     let sum = 0
     let count = 0
     for (const row of group) {
-      const val = await evaluateExpr({ node: args[0], row, tables })
+      const val = await evaluateExpr({ node: args[0], row, tables, functions })
       if (val != null) {
         sum += Number(val)
         count++
@@ -134,7 +140,7 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
   if (funcName === 'MIN') {
     let min = null
     for (const row of group) {
-      const val = await evaluateExpr({ node: args[0], row, tables })
+      const val = await evaluateExpr({ node: args[0], row, tables, functions })
       if (val != null && (min == null || val < min)) {
         min = val
       }
@@ -145,7 +151,7 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
   if (funcName === 'MAX') {
     let max = null
     for (const row of group) {
-      const val = await evaluateExpr({ node: args[0], row, tables })
+      const val = await evaluateExpr({ node: args[0], row, tables, functions })
       if (val != null && (max == null || val > max)) {
         max = val
       }