squirreling 0.4.8 → 0.6.0

package/src/execute/expression.js

@@ -1,12 +1,14 @@
+import { unknownFunctionError } from '../parseErrors.js'
+import { invalidContextError } from '../executionErrors.js'
 import {
   argCountError,
   argValueError,
   castError,
-  invalidContextError,
-  unknownFunctionError,
-} from '../errors.js'
+} from '../validationErrors.js'
+import { 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'
 
 /**
@@ -20,23 +22,24 @@ 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 {number} [params.rowIndex] - 1-based row index for error reporting
  * @returns {Promise<SqlPrimitive>} The result of the evaluation
  */
-export async function evaluateExpr({ node, row, tables }) {
+export async function evaluateExpr({ node, row, tables, rowIndex }) {
   if (node.type === 'literal') {
     return node.value
   }
 
   if (node.type === 'identifier') {
     // Try exact match first (handles both qualified and unqualified names)
-    if (row[node.name]) {
-      return row[node.name]()
+    if (row.cells[node.name]) {
+      return row.cells[node.name]()
     }
     // For qualified names like 'users.id', also try just the column part
     if (node.name.includes('.')) {
       const colName = node.name.split('.').pop()
-      if (colName && row[colName]) {
-        return row[colName]()
+      if (colName && row.cells[colName]) {
+        return row.cells[colName]()
       }
     }
     return null
@@ -45,28 +48,25 @@ export async function evaluateExpr({ node, row, tables }) {
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
     const gen = executeSelect(node.subquery, tables)
-    const first = await gen.next() // Start the generator
+    const { value } = await gen.next() // Start the generator
     gen.return(undefined) // Stop further execution
-    if (!first.value) return null
-    /** @type {AsyncRow} */
-    const firstRow = first.value
-    const firstKey = Object.keys(firstRow)[0]
-    return firstRow[firstKey]()
+    if (!value) return null
+    return value.cells[value.columns[0]]()
   }
 
   // Unary operators
   if (node.type === 'unary') {
     if (node.op === 'NOT') {
-      return !await evaluateExpr({ node: node.argument, row, tables })
+      return !await evaluateExpr({ node: node.argument, row, tables, rowIndex })
     }
     if (node.op === 'IS NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables }) == null
+      return await evaluateExpr({ node: node.argument, row, tables, rowIndex }) == null
     }
     if (node.op === 'IS NOT NULL') {
-      return await evaluateExpr({ node: node.argument, row, tables }) != null
+      return await evaluateExpr({ node: node.argument, row, tables, rowIndex }) != null
     }
     if (node.op === '-') {
-      const val = await evaluateExpr({ node: node.argument, row, tables })
+      const val = await evaluateExpr({ node: node.argument, row, tables, rowIndex })
       if (val == null) return null
       return -val
     }
@@ -76,15 +76,15 @@ export async function evaluateExpr({ node, row, tables }) {
   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 })
+      const dateVal = await evaluateExpr({ node: node.left, row, tables, rowIndex })
       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 })
+      const dateVal = await evaluateExpr({ node: node.right, row, tables, rowIndex })
       return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
     }
 
-    const left = await evaluateExpr({ node: node.left, row, tables })
+    const left = await evaluateExpr({ node: node.left, row, tables, rowIndex })
 
     // Short-circuit evaluation for AND and OR
     if (node.op === 'AND') {
@@ -94,7 +94,7 @@ export async function evaluateExpr({ node, row, tables }) {
       if (left) return true
     }
 
-    const right = await evaluateExpr({ node: node.right, row, tables })
+    const right = await evaluateExpr({ node: node.right, row, tables, rowIndex })
     return applyBinaryOp(node.op, left, right)
   }
 
@@ -102,38 +102,77 @@ export async function evaluateExpr({ node, row, tables }) {
   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 })))
+    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables, rowIndex })))
 
     if (funcName === 'UPPER') {
-      if (args.length !== 1) throw argCountError('UPPER', 1, args.length)
+      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('LOWER', 1, args.length)
+      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('CONCAT', 'at least 1', args.length)
+      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('LENGTH', 1, args.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
@@ -141,7 +180,14 @@ export async function evaluateExpr({ node, row, tables }) {
 
     if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
       if (args.length < 2 || args.length > 3) {
-        throw argCountError(funcName, '2 or 3', args.length)
+        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
@@ -151,7 +197,10 @@ export async function evaluateExpr({ node, row, tables }) {
         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
@@ -162,6 +211,9 @@ export async function evaluateExpr({ node, row, tables }) {
           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)
@@ -170,14 +222,32 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'TRIM') {
-      if (args.length !== 1) throw argCountError('TRIM', 1, args.length)
+      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('REPLACE', 3, args.length)
+      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]
@@ -187,28 +257,71 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'RANDOM' || funcName === 'RAND') {
-      if (args.length !== 0) throw argCountError(funcName, 0, args.length)
+      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('CURRENT_DATE', 0, args.length)
+      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('CURRENT_TIME', 0, args.length)
+      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('CURRENT_TIMESTAMP', 0, args.length)
+      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('JSON_OBJECT', 'even number', args.length)
+        throw argCountError({
+          funcName: 'JSON_OBJECT',
+          expected: 'even number',
+          received: args.length,
+          positionStart: node.positionStart,
+          positionEnd: node.positionEnd,
+          rowNumber: rowIndex,
+        })
       }
       /** @type {Record<string, SqlPrimitive>} */
       const result = {}
@@ -219,7 +332,10 @@ export async function evaluateExpr({ node, row, tables }) {
           throw argValueError({
             funcName: 'JSON_OBJECT',
             message: 'key cannot be null',
+            positionStart: node.positionStart,
+            positionEnd: node.positionEnd,
             hint: 'All keys must be non-null values.',
+            rowNumber: rowIndex,
           })
         }
         result[String(key)] = value
@@ -228,7 +344,16 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
-      if (args.length !== 2) throw argCountError(funcName, 2, args.length)
+      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
@@ -241,7 +366,10 @@ export async function evaluateExpr({ node, row, tables }) {
           throw argValueError({
             funcName,
             message: 'invalid JSON string',
+            positionStart: node.positionStart,
+            positionEnd: node.positionEnd,
             hint: 'First argument must be valid JSON.',
+            rowNumber: rowIndex,
           })
         }
       }
@@ -249,6 +377,9 @@ export async function evaluateExpr({ node, row, tables }) {
         throw argValueError({
           funcName,
           message: `first argument must be JSON string or object, got ${typeof jsonArg}`,
+          positionStart: node.positionStart,
+          positionEnd: node.positionEnd,
+          rowNumber: rowIndex,
         })
       }
 
@@ -278,11 +409,25 @@ export async function evaluateExpr({ node, row, tables }) {
       return current
     }
 
-    throw unknownFunctionError(funcName)
+    if (isMathFunc(funcName)) {
+      return evaluateMathFunc({
+        funcName,
+        args,
+        positionStart: node.positionStart,
+        positionEnd: node.positionEnd,
+        rowNumber: rowIndex,
+      })
+    }
+
+    throw unknownFunctionError({
+      funcName,
+      positionStart: node.positionStart,
+      positionEnd: node.positionEnd,
+    })
   }
 
   if (node.type === 'cast') {
-    const val = await evaluateExpr({ node: node.expr, row, tables })
+    const val = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
     if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
@@ -290,7 +435,15 @@ export async function evaluateExpr({ node, row, tables }) {
       return String(val)
     }
     // Can only cast primitives to other primitive types
-    if (typeof val === 'object') throw castError(node.toType, 'object')
+    if (typeof val === 'object') {
+      throw castError({
+        toType: node.toType,
+        positionStart: node.positionStart,
+        positionEnd: node.positionEnd,
+        fromType: 'object',
+        rowNumber: rowIndex,
+      })
+    }
     if (toType === 'INTEGER' || toType === 'INT') {
       const num = Number(val)
       if (isNaN(num)) return null
@@ -307,30 +460,32 @@ export async function evaluateExpr({ node, row, tables }) {
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }
-    throw castError(node.toType)
+    throw castError({
+      toType: node.toType,
+      positionStart: node.positionStart,
+      positionEnd: node.positionEnd,
+      rowNumber: rowIndex,
+    })
   }
 
   // IN and NOT IN with value lists
   if (node.type === 'in valuelist') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables })
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
     for (const valueNode of node.values) {
-      const val = await evaluateExpr({ node: valueNode, row, tables })
+      const val = await evaluateExpr({ node: valueNode, row, tables, rowIndex })
       if (exprVal === val) return true
     }
     return false
   }
   // IN with subqueries
   if (node.type === 'in') {
-    const exprVal = await evaluateExpr({ node: node.expr, row, tables })
+    const exprVal = await evaluateExpr({ node: node.expr, row, tables, rowIndex })
     const results = executeSelect(node.subquery, tables)
-    /** @type {SqlPrimitive[]} */
-    const values = []
     for await (const resRow of results) {
-      const firstKey = Object.keys(resRow)[0]
-      const val = await resRow[firstKey]()
-      values.push(val)
+      const value = await resRow.cells[resRow.columns[0]]()
+      if (exprVal === value) return true
     }
-    return values.includes(exprVal)
+    return false
   }
 
   // EXISTS and NOT EXISTS with subqueries
@@ -346,28 +501,28 @@ export async function evaluateExpr({ node, row, tables }) {
   // 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 })
+    const caseValue = node.caseExpr && await evaluateExpr({ node: node.caseExpr, row, tables, rowIndex })
 
     // 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 })
+        const whenValue = await evaluateExpr({ node: whenClause.condition, row, tables, rowIndex })
         conditionResult = caseValue === whenValue
       } else {
         // Searched CASE: evaluate condition as boolean
-        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables })
+        conditionResult = await evaluateExpr({ node: whenClause.condition, row, tables, rowIndex })
       }
 
       if (conditionResult) {
-        return evaluateExpr({ node: whenClause.result, row, tables })
+        return evaluateExpr({ node: whenClause.result, row, tables, rowIndex })
       }
     }
 
     // No WHEN clause matched, return ELSE result or NULL
     if (node.elseResult) {
-      return evaluateExpr({ node: node.elseResult, row, tables })
+      return evaluateExpr({ node: node.elseResult, row, tables, rowIndex })
     }
     return null
   }
@@ -378,6 +533,9 @@ export async function evaluateExpr({ node, row, tables }) {
     throw invalidContextError({
       item: 'INTERVAL',
       validContext: 'date arithmetic (+ or -)',
+      positionStart: node.positionStart,
+      positionEnd: node.positionEnd,
+      rowNumber: rowIndex,
     })
   }
 

package/src/execute/having.js

@@ -1,4 +1,4 @@
-import { unknownFunctionError } from '../errors.js'
+import { unknownFunctionError } from '../parseErrors.js'
 import { isAggregateFunc } from '../validation.js'
 import { evaluateExpr } from './expression.js'
 import { applyBinaryOp } from './utils.js'
@@ -153,5 +153,10 @@ async function evaluateAggregateFunction(funcName, args, group, tables) {
     return max
   }
 
-  throw unknownFunctionError(funcName, undefined, 'COUNT, SUM, AVG, MIN, MAX')
+  throw unknownFunctionError({
+    funcName,
+    positionStart: 0,
+    positionEnd: 0,
+    validFunctions: 'COUNT, SUM, AVG, MIN, MAX',
+  })
 }