squirreling 0.6.1 → 0.7.1

package/src/execute/expression.js

@@ -1,19 +1,16 @@
 import { unknownFunctionError } from '../parseErrors.js'
 import { invalidContextError } from '../executionErrors.js'
-import {
-  aggregateError,
-  argCountError,
-  argValueError,
-  castError,
-} from '../validationErrors.js'
-import { isAggregateFunc, isMathFunc } from '../validation.js'
+import { aggregateError, argValueError, castError } from '../validationErrors.js'
+import { isAggregateFunc, isMathFunc, isRegexpFunc, isStringFunc } from '../validation.js'
 import { applyIntervalToDate } from './date.js'
 import { executeSelect } from './execute.js'
 import { evaluateMathFunc } from './math.js'
+import { evaluateRegexpFunc } from './regexp.js'
+import { evaluateStringFunc } from './strings.js'
 import { applyBinaryOp, stringify } from './utils.js'
 
 /**
- * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, IntervalUnit } from '../types.js'
+ * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, UserDefinedFunction } from '../types.js'
  */
 
 /**
@@ -23,11 +20,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, rows }) {
+export async function evaluateExpr({ node, row, tables, functions, rowIndex, rows }) {
   if (node.type === 'literal') {
     return node.value
   }
@@ -59,16 +57,16 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
   // Unary operators
   if (node.type === 'unary') {
     if (node.op === 'NOT') {
-      return !await evaluateExpr({ node: node.argument, row, tables, rowIndex, rows })
+      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, rows }) == 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, rows }) != 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, rows })
+      const val = await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows })
       if (val == null) return null
       return -val
     }
@@ -78,15 +76,15 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
   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, rows })
+      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, rows })
+      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, rows })
+    const left = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows })
 
     // Short-circuit evaluation for AND and OR
     if (node.op === 'AND') {
@@ -96,7 +94,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
       if (left) return true
     }
 
-    const right = await evaluateExpr({ node: node.right, row, tables, rowIndex, rows })
+    const right = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows })
     return applyBinaryOp(node.op, left, right)
   }
 
@@ -124,31 +122,20 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
         })
       }
 
-      if (node.args.length !== 1) {
-        throw argCountError({
-          funcName,
-          expected: 1,
-          received: node.args.length,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
-        })
-      }
-
       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 })
+            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 })
+          const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
           if (v != null) count++
         }
         return count
@@ -163,7 +150,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
         let max = null
 
         for (const r of rows) {
-          const raw = await evaluateExpr({ node: argNode, row: r, tables })
+          const raw = await evaluateExpr({ node: argNode, row: r, tables, functions })
           if (raw == null) continue
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
@@ -191,7 +178,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
         if (node.distinct) {
           const seen = new Set()
           for (const r of rows) {
-            const v = await evaluateExpr({ node: argNode, row: r, tables })
+            const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
             const key = stringify(v)
             if (!seen.has(key)) {
               seen.add(key)
@@ -200,7 +187,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
           }
         } else {
           for (const r of rows) {
-            const v = await evaluateExpr({ node: argNode, row: r, tables })
+            const v = await evaluateExpr({ node: argNode, row: r, tables, functions })
             values.push(v)
           }
         }
@@ -209,222 +196,54 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
     }
 
     /** @type {SqlPrimitive[]} */
-    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, rowIndex, rows })))
-
-    if (funcName === 'UPPER') {
-      if (args.length !== 1) {
-        throw argCountError({
-          funcName: 'UPPER',
-          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).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')) {
-        throw argValueError({
-          funcName: 'CONCAT',
-          message: 'does not support object arguments',
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          hint: 'Use CAST to convert objects to strings first.',
-          rowNumber: rowIndex,
-        })
-      }
-      return args.map(a => String(a)).join('')
-    }
-
-    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
-    }
+    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows })))
 
-    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)
-      const start = Number(args[1])
-      if (!Number.isInteger(start) || start < 1) {
-        throw argValueError({
-          funcName,
-          message: `start position must be a positive integer, got ${args[1]}`,
-          positionStart: node.positionStart,
-          positionEnd: node.positionEnd,
-          hint: 'SQL uses 1-based indexing.',
-          rowNumber: rowIndex,
-        })
-      }
-      // SQL uses 1-based indexing
-      const startIdx = start - 1
-      if (args.length === 3) {
-        const len = Number(args[2])
-        if (!Number.isInteger(len) || len < 0) {
-          throw argValueError({
-            funcName,
-            message: `length must be a non-negative integer, got ${args[2]}`,
-            positionStart: node.positionStart,
-            positionEnd: node.positionEnd,
-            rowNumber: rowIndex,
-          })
-        }
-        return strVal.substring(startIdx, startIdx + len)
-      }
-      return strVal.substring(startIdx)
-    }
-
-    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 (isStringFunc(funcName)) {
+      return evaluateStringFunc({
+        funcName,
+        args,
+        positionStart: node.positionStart,
+        positionEnd: node.positionEnd,
+        rowIndex,
+      })
     }
 
-    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]
-      // SQL REPLACE returns NULL if any argument is NULL
-      if (str == null || searchStr == null || replaceStr == null) return null
-      return String(str).replaceAll(String(searchStr), String(replaceStr))
+    if (isRegexpFunc(funcName)) {
+      return evaluateRegexpFunc({
+        funcName,
+        args,
+        positionStart: node.positionStart,
+        positionEnd: node.positionEnd,
+        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,
-        })
+    if (funcName === 'COALESCE') {
+      // Short-circuit: evaluate args one at a time, return first non-null
+      for (const arg of node.args) {
+        const val = await evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows })
+        if (val != null) return val
       }
-      return Math.random()
+      return null
     }
 
     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,
@@ -451,16 +270,6 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
     }
 
     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
@@ -517,13 +326,15 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
     }
 
     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].apply(...args)
+      }
     }
 
     throw unknownFunctionError({
@@ -534,7 +345,7 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
   }
 
   if (node.type === 'cast') {
-    const val = await evaluateExpr({ node: node.expr, row, tables, rowIndex, rows })
+    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') {
@@ -577,16 +388,16 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
 
   // IN and NOT IN with value lists
   if (node.type === 'in valuelist') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, rowIndex, rows })
+    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, rows })
+      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, rows })
+    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]]()
@@ -608,28 +419,28 @@ export async function evaluateExpr({ node, row, tables, rowIndex, rows }) {
   // 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, rows })
+    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, rows })
+        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, rows })
+        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows })
       }
 
       if (conditionResult) {
-        return evaluateExpr({ node: whenClause.result, row, tables, rowIndex, rows })
+        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, rows })
+      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
       }