squirreling 0.4.7 → 0.5.0

package/src/execute/expression.js

@@ -1,8 +1,18 @@
+import { unknownFunctionError } from '../parseErrors.js'
+import { invalidContextError } from '../executionErrors.js'
+import {
+  argCountError,
+  argValueError,
+  castError,
+} 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'
 
 /**
- * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource } from '../types.js'
+ * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource, IntervalUnit } from '../types.js'
  */
 
 /**
@@ -12,9 +22,10 @@ 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
   }
@@ -31,7 +42,7 @@ export async function evaluateExpr({ node, row, tables }) {
         return row[colName]()
       }
     }
-    return undefined
+    return null
   }
 
   // Scalar subquery - returns a single value
@@ -49,16 +60,16 @@ export async function evaluateExpr({ node, row, tables }) {
   // 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
     }
@@ -66,7 +77,17 @@ export async function evaluateExpr({ node, row, tables }) {
 
   // Binary operators
   if (node.type === 'binary') {
-    const left = await evaluateExpr({ node: node.left, row, tables })
+    // 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 })
+      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 })
+      return applyIntervalToDate(dateVal, node.left.value, node.left.unit, '+')
+    }
+
+    const left = await evaluateExpr({ node: node.left, row, tables, rowIndex })
 
     // Short-circuit evaluation for AND and OR
     if (node.op === 'AND') {
@@ -76,7 +97,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)
   }
 
@@ -84,34 +105,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 new Error('UPPER requires exactly 1 argument')
+      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 new Error('LOWER requires exactly 1 argument')
+      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 new Error('CONCAT requires at least 1 argument')
+      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 new Error('CONCAT does not support object arguments')
+        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 new Error('LENGTH requires exactly 1 argument')
+      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
@@ -119,21 +183,41 @@ export async function evaluateExpr({ node, row, tables }) {
 
     if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
       if (args.length < 2 || args.length > 3) {
-        throw new Error(`${funcName} requires 2 or 3 arguments`)
+        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 new Error(`${funcName} start position must be a positive integer`)
+        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 new Error(`${funcName} length must be a non-negative integer`)
+          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)
       }
@@ -141,14 +225,32 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'TRIM') {
-      if (args.length !== 1) throw new Error('TRIM requires exactly 1 argument')
+      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 new Error('REPLACE requires exactly 3 arguments')
+      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]
@@ -158,13 +260,71 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'RANDOM' || funcName === 'RAND') {
-      if (args.length !== 0) throw new Error(`${funcName} takes no arguments`)
+      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 new Error('JSON_OBJECT requires an even number of arguments (key-value pairs)')
+        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 = {}
@@ -172,7 +332,14 @@ export async function evaluateExpr({ node, row, tables }) {
         const key = args[i]
         const value = args[i + 1]
         if (key == null) {
-          throw new Error('JSON_OBJECT: key cannot be null')
+          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
       }
@@ -180,7 +347,16 @@ export async function evaluateExpr({ node, row, tables }) {
     }
 
     if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
-      if (args.length !== 2) throw new Error(`${funcName} requires exactly 2 arguments`)
+      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
@@ -190,11 +366,24 @@ export async function evaluateExpr({ node, row, tables }) {
         try {
           jsonArg = JSON.parse(jsonArg)
         } catch {
-          throw new Error(`${funcName}: invalid JSON string`)
+          throw argValueError({
+            funcName,
+            message: 'invalid JSON string',
+            positionStart: node.positionStart,
+            positionEnd: node.positionEnd,
+            hint: 'First argument must be valid JSON.',
+            rowNumber: rowIndex,
+          })
         }
       }
-      if (typeof jsonArg !== 'object') {
-        throw new Error(`${funcName}: first argument must be JSON string or object`)
+      if (typeof jsonArg !== 'object' || jsonArg instanceof Date) {
+        throw argValueError({
+          funcName,
+          message: `first argument must be JSON string or object, got ${typeof jsonArg}`,
+          positionStart: node.positionStart,
+          positionEnd: node.positionEnd,
+          rowNumber: rowIndex,
+        })
       }
 
       // Parse path ("$.foo.bar[0].baz" or "foo.bar[0]")
@@ -223,11 +412,25 @@ export async function evaluateExpr({ node, row, tables }) {
       return current
     }
 
-    throw new Error('Unsupported function ' + 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') {
@@ -235,7 +438,15 @@ export async function evaluateExpr({ node, row, tables }) {
       return String(val)
     }
     // Can only cast primitives to other primitive types
-    if (typeof val === 'object') throw new Error(`Cannot CAST object to type ${node.toType}`)
+    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
@@ -252,21 +463,26 @@ export async function evaluateExpr({ node, row, tables }) {
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }
-    throw new Error('Unsupported CAST to type ' + 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 = []
@@ -291,31 +507,43 @@ 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
   }
 
-  throw new Error('Unknown expression node type ' + node.type)
+  // INTERVAL expressions should only appear as part of binary +/- operations
+  // which are handled above. A standalone interval is an error.
+  if (node.type === 'interval') {
+    throw invalidContextError({
+      item: 'INTERVAL',
+      validContext: 'date arithmetic (+ or -)',
+      positionStart: node.positionStart,
+      positionEnd: node.positionEnd,
+      rowNumber: rowIndex,
+    })
+  }
+
+  throw new Error(`Unknown expression node type: ${node.type}. This is an internal error - the query may contain unsupported syntax.`)
 }

package/src/execute/having.js

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

package/src/execute/join.js

@@ -1,3 +1,5 @@
+import { missingClauseError } from '../parseErrors.js'
+import { tableNotFoundError } from '../executionErrors.js'
 import { evaluateExpr } from './expression.js'
 import { stringify } from './utils.js'
 
@@ -22,7 +24,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[0]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw new Error(`Table "${join.table}" not found`)
+      throw tableNotFoundError({ tableName: join.table })
     }
 
     // Buffer right rows for hash index (required for hash join)
@@ -62,7 +64,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[i]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw new Error(`Table "${join.table}" not found`)
+      throw tableNotFoundError({ tableName: join.table })
     }
 
     /** @type {AsyncRow[]} */
@@ -98,7 +100,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
   const lastJoin = joins[joins.length - 1]
   const rightSource = tables[lastJoin.table]
   if (rightSource === undefined) {
-    throw new Error(`Table "${lastJoin.table}" not found`)
+    throw tableNotFoundError({ tableName: lastJoin.table })
   }
 
   /** @type {AsyncRow[]} */
@@ -234,7 +236,10 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
   const { joinType, on: onCondition } = join
 
   if (!onCondition) {
-    throw new Error('JOIN requires ON condition')
+    throw missingClauseError({
+      missing: 'ON condition',
+      context: 'JOIN',
+    })
   }
 
   const keys = extractJoinKeys(onCondition, leftTable, rightTable)