squirreling 0.7.9 → 0.8.0

package/src/execute/utils.js

@@ -1,55 +1,7 @@
 /**
- * @import { AsyncRow, BinaryOp, ExprNode, OrderByItem, SqlPrimitive } from '../types.js'
+ * @import { AsyncCells, AsyncRow, ExprNode, OrderByItem, SqlPrimitive } from '../types.js'
  */
 
-/**
- * Applies a binary operator to two values, handling nulls according to SQL semantics
- *
- * @param {BinaryOp} op
- * @param {SqlPrimitive} a
- * @param {SqlPrimitive} b
- * @returns {SqlPrimitive}
- */
-export function applyBinaryOp(op, a, b) {
-  // Arithmetic operators return null if either operand is null
-  if (op === '+' || op === '-' || op === '*' || op === '/' || op === '%') {
-    if (a == null || b == null) return null
-    const numA = Number(a)
-    const numB = Number(b)
-    if (op === '+') return numA + numB
-    if (op === '-') return numA - numB
-    if (op === '*') return numA * numB
-    if (op === '/') return numB === 0 ? null : numA / numB
-    if (op === '%') return numB === 0 ? null : numA % numB
-  }
-
-  // Comparison and logical operators
-  if (a == null || b == null) {
-    return false
-  }
-  if (op === 'AND') return Boolean(a) && Boolean(b)
-  if (op === 'OR') return Boolean(a) || Boolean(b)
-  if (op === '!=' || op === '<>') return a != b
-  if (op === '=') return a == b
-  if (op === '<') return a < b
-  if (op === '<=') return a <= b
-  if (op === '>') return a > b
-  if (op === '>=') return a >= b
-
-  if (op === 'LIKE') {
-    const str = String(a)
-    const pattern = String(b)
-    const regexPattern = pattern
-      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-      .replace(/%/g, '.*')
-      .replace(/_/g, '.')
-    const regex = new RegExp(`^${regexPattern}$`, 'i')
-    return regex.test(str)
-  }
-
-  return null
-}
-
 /**
  * Compares two values for a single ORDER BY term, handling nulls and direction
  *
@@ -157,3 +109,20 @@ export function stringify(value) {
     return val
   })
 }
+
+/**
+ * Creates a stable string key for a row to enable deduplication
+ *
+ * @param {AsyncCells} cells
+ * @returns {Promise<string>}
+ */
+export async function stableRowKey(cells) {
+  const keys = Object.keys(cells).sort()
+  /** @type {string[]} */
+  const parts = []
+  for (const k of keys) {
+    const v = await cells[k]()
+    parts.push(k + ':' + stringify(v))
+  }
+  return parts.join('|')
+}

package/src/executionErrors.js

@@ -11,15 +11,15 @@ export class ExecutionError extends Error {
    * @param {string} options.message - Human-readable error message
    * @param {number} options.positionStart - Start position (0-based character offset)
    * @param {number} options.positionEnd - End position (exclusive, 0-based character offset)
-   * @param {number} [options.rowNumber] - 1-based row number where error occurred
+   * @param {number} [options.rowIndex] - 1-based row number where error occurred
    */
-  constructor({ message, positionStart, positionEnd, rowNumber }) {
-    const rowSuffix = rowNumber != null ? ` (row ${rowNumber})` : ''
+  constructor({ message, positionStart, positionEnd, rowIndex }) {
+    const rowSuffix = rowIndex != null ? ` (row ${rowIndex})` : ''
     super(message + rowSuffix)
     this.name = 'ExecutionError'
     this.positionStart = positionStart
     this.positionEnd = positionEnd
-    this.rowNumber = rowNumber
+    this.rowIndex = rowIndex
   }
 }
 
@@ -40,11 +40,11 @@ export function tableNotFoundError({ tableName }) {
  * @param {string} options.validContext - Where it can be used
  * @param {number} options.positionStart - Start position in query
  * @param {number} options.positionEnd - End position in query
- * @param {number} [options.rowNumber] - 1-based row number where error occurred
+ * @param {number} [options.rowIndex] - 1-based row number where error occurred
  * @returns {ExecutionError}
  */
-export function invalidContextError({ item, validContext, positionStart, positionEnd, rowNumber }) {
-  return new ExecutionError({ message: `${item} can only be used with ${validContext}`, positionStart, positionEnd, rowNumber })
+export function invalidContextError({ item, validContext, positionStart, positionEnd, rowIndex }) {
+  return new ExecutionError({ message: `${item} can only be used with ${validContext}`, positionStart, positionEnd, rowIndex })
 }
 
 /**
@@ -64,10 +64,10 @@ export function unsupportedOperationError({ operation, hint }) {
  * @param {string[]} options.availableColumns - List of available column names
  * @param {number} options.positionStart - Start position in query
  * @param {number} options.positionEnd - End position in query
- * @param {number} [options.rowNumber] - 1-based row number where error occurred
+ * @param {number} [options.rowIndex] - 1-based row number where error occurred
  * @returns {ExecutionError}
  */
-export function columnNotFoundError({ columnName, availableColumns, positionStart, positionEnd, rowNumber }) {
+export function columnNotFoundError({ columnName, availableColumns, positionStart, positionEnd, rowIndex }) {
   const available = availableColumns.length > 0
     ? `. Available columns: ${availableColumns.join(', ')}`
     : ''
@@ -75,6 +75,6 @@ export function columnNotFoundError({ columnName, availableColumns, positionStar
     message: `Column "${columnName}" not found${available}`,
     positionStart,
     positionEnd,
-    rowNumber,
+    rowIndex,
   })
 }

package/src/expression/binary.js

@@ -0,0 +1,51 @@
+/**
+ * @import { BinaryOp, SqlPrimitive } from '../types.js'
+ */
+
+/**
+ * Applies a binary operator to two values, handling nulls according to SQL semantics
+ *
+ * @param {BinaryOp} op
+ * @param {SqlPrimitive} a
+ * @param {SqlPrimitive} b
+ * @returns {SqlPrimitive}
+ */
+export function applyBinaryOp(op, a, b) {
+  // Arithmetic operators return null if either operand is null
+  if (op === '+' || op === '-' || op === '*' || op === '/' || op === '%') {
+    if (a == null || b == null) return null
+    const numA = Number(a)
+    const numB = Number(b)
+    if (op === '+') return numA + numB
+    if (op === '-') return numA - numB
+    if (op === '*') return numA * numB
+    if (op === '/') return numB === 0 ? null : numA / numB
+    if (op === '%') return numB === 0 ? null : numA % numB
+  }
+
+  // Comparison and logical operators
+  if (a == null || b == null) {
+    return false
+  }
+  if (op === 'AND') return Boolean(a) && Boolean(b)
+  if (op === 'OR') return Boolean(a) || Boolean(b)
+  if (op === '!=' || op === '<>') return a != b
+  if (op === '=') return a == b
+  if (op === '<') return a < b
+  if (op === '<=') return a <= b
+  if (op === '>') return a > b
+  if (op === '>=') return a >= b
+
+  if (op === 'LIKE') {
+    const str = String(a)
+    const pattern = String(b)
+    const regexPattern = pattern
+      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/%/g, '.*')
+      .replace(/_/g, '.')
+    const regex = new RegExp(`^${regexPattern}$`, 'i')
+    return regex.test(str)
+  }
+
+  return null
+}

package/src/{execute → expression}/date.js

@@ -2,29 +2,13 @@
  * @import { SqlPrimitive, IntervalUnit } from '../types.js'
  */
 
-/**
- * @param {SqlPrimitive} val
- * @returns {Date | null}
- */
-function toDate(val) {
-  if (val instanceof Date) return val
-  const dateOrTime = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/
-  if (typeof val === 'string' && dateOrTime.test(val)) {
-    const date = new Date(val)
-    if (!isNaN(date.getTime())) {
-      return date
-    }
-  }
-  return null
-}
-
 /**
  * Apply an interval to a date
  * @param {SqlPrimitive} dateVal
  * @param {number} value
  * @param {IntervalUnit} unit
  * @param {'+' | '-'} op
- * @returns {string | null}
+ * @returns {Date | string | null}
  */
 export function applyIntervalToDate(dateVal, value, unit, op) {
   const date = toDate(dateVal)
@@ -48,10 +32,26 @@ export function applyIntervalToDate(dateVal, value, unit, op) {
   }
 
   // Return in same format as input
-  if (dateVal instanceof Date) return date.toISOString()
+  if (dateVal instanceof Date) return date
   if (String(dateVal).includes('T')) {
     return date.toISOString()
   } else {
     return date.toISOString().split('T')[0]
   }
 }
+
+/**
+ * @param {SqlPrimitive} val
+ * @returns {Date | null}
+ */
+function toDate(val) {
+  if (val instanceof Date) return val
+  const dateOrTime = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/
+  if (typeof val === 'string' && dateOrTime.test(val)) {
+    const date = new Date(val)
+    if (!isNaN(date.getTime())) {
+      return date
+    }
+  }
+  return null
+}

package/src/{execute/expression.js → expression/evaluate.js}

@@ -1,13 +1,14 @@
-import { unknownFunctionError } from '../parseErrors.js'
+import { executeSelect } from '../execute/execute.js'
+import { stringify } from '../execute/utils.js'
 import { columnNotFoundError, invalidContextError } from '../executionErrors.js'
+import { unknownFunctionError } from '../parseErrors.js'
 import { aggregateError, argValueError, castError } from '../validationErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isStringFunc } from '../validation.js'
+import { applyBinaryOp } from './binary.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, UserDefinedFunction } from '../types.js'
@@ -24,9 +25,10 @@ import { applyBinaryOp, stringify } from './utils.js'
  * @param {number} [params.rowIndex] - 1-based row index for error reporting
  * @param {AsyncRow[]} [params.rows] - Group of rows for aggregate functions
  * @param {Map<string, ExprNode>} [params.aliases] - SELECT column aliases for ORDER BY resolution
+ * @param {AbortSignal} [params.signal] - abort signal for cancellation
  * @returns {Promise<SqlPrimitive>} The result of the evaluation
  */
-export async function evaluateExpr({ node, row, tables, functions, rowIndex, rows, aliases }) {
+export async function evaluateExpr({ node, row, tables, functions, rowIndex, rows, aliases, signal }) {
   if (node.type === 'literal') {
     return node.value
   }
@@ -45,7 +47,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     }
     // Check if it's a SELECT alias (for ORDER BY)
     if (aliases?.has(node.name)) {
-      return evaluateExpr({ node: aliases.get(node.name), row, tables, functions, rowIndex, rows, aliases })
+      return evaluateExpr({ node: aliases.get(node.name), row, tables, functions, rowIndex, rows, aliases, signal })
     }
     // Unknown identifier
     throw columnNotFoundError({
@@ -53,13 +55,13 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       availableColumns: Object.keys(row.cells),
       positionStart: node.positionStart,
       positionEnd: node.positionEnd,
-      rowNumber: rowIndex,
+      rowIndex,
     })
   }
 
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
-    const gen = executeSelect({ select: node.subquery, tables })
+    const gen = executeSelect({ select: node.subquery, tables, functions, signal })
     const { value } = await gen.next() // Start the generator
     gen.return(undefined) // Stop further execution
     if (!value) return null
@@ -68,45 +70,35 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // Unary operators
   if (node.type === 'unary') {
-    if (node.op === 'NOT') {
-      return !await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases })
-    }
-    if (node.op === 'IS NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases }) == null
-    }
-    if (node.op === 'IS NOT NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases }) != null
-    }
+    const val = await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases, signal })
     if (node.op === '-') {
-      const val = await evaluateExpr({ node: node.argument, row, tables, functions, rowIndex, rows, aliases })
       if (val == null) return null
       return -val
     }
+    if (node.op === 'NOT') return !val
+    if (node.op === 'IS NULL') return val == null
+    if (node.op === 'IS NOT NULL') return val != null
   }
 
   // Binary operators
   if (node.type === 'binary') {
-    // Handle date +/- interval at AST level
+    // Handle date +/- interval
     if ((node.op === '+' || node.op === '-') && node.right.type === 'interval') {
-      const dateVal = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases })
+      const dateVal = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases, signal })
       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, functions, rowIndex, rows, aliases })
+      const dateVal = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows, aliases, signal })
       return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
     }
 
-    const left = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases })
+    const left = await evaluateExpr({ node: node.left, row, tables, functions, rowIndex, rows, aliases, signal })
 
     // Short-circuit evaluation for AND and OR
-    if (node.op === 'AND') {
-      if (!left) return false
-    }
-    if (node.op === 'OR') {
-      if (left) return true
-    }
+    if (node.op === 'AND' && !left) return false
+    if (node.op === 'OR' && left) return true
 
-    const right = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows, aliases })
+    const right = await evaluateExpr({ node: node.right, row, tables, functions, rowIndex, rows, aliases, signal })
     return applyBinaryOp(node.op, left, right)
   }
 
@@ -119,7 +111,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       if (!rows) {
         throw aggregateError({
           funcName,
-          issue: 'requires GROUP BY or will act on the whole dataset',
+          issue: ' is not allowed outside of aggregate context',
         })
       }
 
@@ -128,7 +120,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       if (node.filter) {
         filteredRows = []
         for (const row of rows) {
-          const passes = await evaluateExpr({ node: node.filter, row, tables, functions })
+          const passes = await evaluateExpr({ node: node.filter, row, tables, functions, signal })
           if (passes) filteredRows.push(row)
         }
       }
@@ -140,7 +132,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         }
         throw aggregateError({
           funcName,
-          issue: '(*) is not supported, use a column name',
+          issue: '(*) is not supported. Only COUNT supports *.',
         })
       }
 
@@ -150,14 +142,14 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         if (node.distinct) {
           const seen = new Set()
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions })
+            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
             if (v != null) seen.add(v)
           }
           return seen.size
         }
         let count = 0
         for (const row of filteredRows) {
-          const v = await evaluateExpr({ node: argNode, row, tables, functions })
+          const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
           if (v != null) count++
         }
         return count
@@ -172,7 +164,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         let max = null
 
         for (const row of filteredRows) {
-          const raw = await evaluateExpr({ node: argNode, row, tables, functions })
+          const raw = await evaluateExpr({ node: argNode, row, tables, functions, signal })
           if (raw == null) continue
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
@@ -197,7 +189,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       if (funcName === 'STDDEV_SAMP' || funcName === 'STDDEV_POP') {
         const values = []
         for (const row of filteredRows) {
-          const raw = await evaluateExpr({ node: argNode, row, tables, functions })
+          const raw = await evaluateExpr({ node: argNode, row, tables, functions, signal })
           if (raw == null) continue
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
@@ -219,7 +211,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         if (node.distinct) {
           const seen = new Set()
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions })
+            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
             const key = stringify(v)
             if (!seen.has(key)) {
               seen.add(key)
@@ -228,7 +220,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
           }
         } else {
           for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, tables, functions })
+            const v = await evaluateExpr({ node: argNode, row, tables, functions, signal })
             values.push(v)
           }
         }
@@ -237,7 +229,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
     }
 
     /** @type {SqlPrimitive[]} */
-    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows, aliases })))
+    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows, aliases, signal })))
 
     if (isStringFunc(funcName)) {
       return evaluateStringFunc({
@@ -259,15 +251,26 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       })
     }
 
+    if (isMathFunc(funcName)) {
+      return evaluateMathFunc({ funcName, args })
+    }
+
     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 })
+        const val = await evaluateExpr({ node: arg, row, tables, functions, rowIndex, rows, signal })
         if (val != null) return val
       }
       return null
     }
 
+    if (funcName === 'NULLIF') {
+      // NULLIF(a, b) returns null if a = b, otherwise returns a
+      const val1 = await evaluateExpr({ node: node.args[0], row, tables, functions, rowIndex, rows, signal })
+      const val2 = await evaluateExpr({ node: node.args[1], row, tables, functions, rowIndex, rows, signal })
+      return val1 == val2 ? null : val1
+    }
+
     if (funcName === 'CURRENT_DATE') {
       return new Date().toISOString().split('T')[0]
     }
@@ -287,7 +290,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
           message: 'requires an even number of arguments (key-value pairs)',
           positionStart: node.positionStart,
           positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
       /** @type {Record<string, SqlPrimitive>} */
@@ -302,7 +305,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
             positionStart: node.positionStart,
             positionEnd: node.positionEnd,
             hint: 'All keys must be non-null values.',
-            rowNumber: rowIndex,
+            rowIndex,
           })
         }
         result[String(key)] = value
@@ -326,7 +329,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
             positionStart: node.positionStart,
             positionEnd: node.positionEnd,
             hint: 'First argument must be valid JSON.',
-            rowNumber: rowIndex,
+            rowIndex,
           })
         }
       }
@@ -336,7 +339,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
           message: `first argument must be JSON string or object, got ${typeof jsonArg}`,
           positionStart: node.positionStart,
           positionEnd: node.positionEnd,
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
 
@@ -366,10 +369,6 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       return current
     }
 
-    if (isMathFunc(funcName)) {
-      return evaluateMathFunc({ funcName, args })
-    }
-
     // Check user-defined functions (case-insensitive lookup)
     if (functions) {
       const udfName = Object.keys(functions).find(k => k.toUpperCase() === funcName)
@@ -386,7 +385,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
   }
 
   if (node.type === 'cast') {
-    const val = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
+    const val = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
     if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
@@ -400,7 +399,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
         positionStart: node.positionStart,
         positionEnd: node.positionEnd,
         fromType: 'object',
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
     if (toType === 'INTEGER' || toType === 'INT') {
@@ -423,23 +422,23 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       toType: node.toType,
       positionStart: node.positionStart,
       positionEnd: node.positionEnd,
-      rowNumber: rowIndex,
+      rowIndex,
     })
   }
 
   // IN and NOT IN with value lists
   if (node.type === 'in valuelist') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
     for (const valueNode of node.values) {
-      const val = await evaluateExpr({ node: valueNode, row, tables, functions, rowIndex, rows })
+      const val = await evaluateExpr({ node: valueNode, row, tables, functions, rowIndex, rows, signal })
       if (exprVal == val) return true
     }
     return false
   }
   // IN with subqueries
   if (node.type === 'in') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows })
-    const results = executeSelect({ select: node.subquery, tables })
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, functions, rowIndex, rows, signal })
+    const results = executeSelect({ select: node.subquery, tables, functions, signal })
     for await (const resRow of results) {
       const value = await resRow.cells[resRow.columns[0]]()
       if (exprVal == value) return true
@@ -449,39 +448,39 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
 
   // EXISTS and NOT EXISTS with subqueries
   if (node.type === 'exists') {
-    const results = await executeSelect({ select: node.subquery, tables }).next()
+    const results = await executeSelect({ select: node.subquery, tables, functions, signal }).next()
     return results.done === false
   }
   if (node.type === 'not exists') {
-    const results = await executeSelect({ select: node.subquery, tables }).next()
+    const results = await executeSelect({ select: node.subquery, tables, functions, signal }).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, functions, rowIndex, rows })
+    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, tables, functions, rowIndex, rows, signal })
 
     // 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, functions, rowIndex, rows })
+        const whenValue = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows, signal })
         conditionResult = caseValue == whenValue
       } else {
         // Searched CASE: evaluate condition as boolean
-        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows })
+        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, functions, rowIndex, rows, signal })
       }
 
       if (conditionResult) {
-        return evaluateExpr({ node: whenClause.result, row, tables, functions, rowIndex, rows })
+        return evaluateExpr({ node: whenClause.result, row, tables, functions, rowIndex, rows, signal })
       }
     }
 
     // No WHEN clause matched, return ELSE result or NULL
     if (node.elseResult) {
-      return evaluateExpr({ node: node.elseResult, row, tables, functions, rowIndex, rows })
+      return evaluateExpr({ node: node.elseResult, row, tables, functions, rowIndex, rows, signal })
     }
     return null
   }
@@ -494,7 +493,7 @@ export async function evaluateExpr({ node, row, tables, functions, rowIndex, row
       validContext: 'date arithmetic (+ or -)',
       positionStart: node.positionStart,
       positionEnd: node.positionEnd,
-      rowNumber: rowIndex,
+      rowIndex,
     })
   }