squirreling 0.4.8 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "Squirreling SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,10 +37,10 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "24.10.1",
+    "@types/node": "24.10.2",
     "@vitest/coverage-v8": "4.0.15",
     "eslint": "9.39.1",
-    "eslint-plugin-jsdoc": "61.4.2",
+    "eslint-plugin-jsdoc": "61.5.0",
     "typescript": "5.9.3",
     "vitest": "4.0.15"
   }

package/src/execute/aggregates.js

@@ -1,4 +1,5 @@
-import { aggregateError, unknownFunctionError } from '../errors.js'
+import { unknownFunctionError } from '../parseErrors.js'
+import { aggregateError } from '../validationErrors.js'
 import { evaluateExpr } from './expression.js'
 import { defaultDerivedAlias, stringify } from './utils.js'
 
@@ -39,7 +40,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
 
   if (func === 'SUM' || func === 'AVG' || func === 'MIN' || func === 'MAX') {
     if (arg.kind === 'star') {
-      throw aggregateError(func, '(*) is not supported, use a column name')
+      throw aggregateError({ funcName: func, issue: '(*) is not supported, use a column name' })
     }
     let sum = 0
     let count = 0
@@ -73,7 +74,7 @@ export async function evaluateAggregate({ col, rows, tables }) {
 
   if (func === 'JSON_ARRAYAGG') {
     if (arg.kind === 'star') {
-      throw aggregateError('JSON_ARRAYAGG', '(*) is not supported, use a column name or expression')
+      throw aggregateError({ funcName: 'JSON_ARRAYAGG', issue: '(*) is not supported, use a column name or expression' })
     }
     /** @type {SqlPrimitive[]} */
     const values = []
@@ -96,7 +97,12 @@ export async function evaluateAggregate({ col, rows, tables }) {
     return values
   }
 
-  throw unknownFunctionError(func, undefined, 'COUNT, SUM, AVG, MIN, MAX, JSON_ARRAYAGG')
+  throw unknownFunctionError({
+    funcName: func,
+    positionStart: 0,
+    positionEnd: 0,
+    validFunctions: 'COUNT, SUM, AVG, MIN, MAX, JSON_ARRAYAGG',
+  })
 }
 
 /**

package/src/execute/execute.js

@@ -1,4 +1,5 @@
-import { missingClauseError, tableNotFoundError, unsupportedOperationError } from '../errors.js'
+import { missingClauseError } from '../parseErrors.js'
+import { tableNotFoundError, unsupportedOperationError } from '../executionErrors.js'
 import { generatorSource, memorySource } from '../backend/dataSource.js'
 import { parseSql } from '../parse/parse.js'
 import { defaultAggregateAlias, evaluateAggregate } from './aggregates.js'
@@ -61,7 +62,7 @@ export async function* executeSelect(select, tables) {
     fromTableName = select.from.alias ?? select.from.table
     dataSource = tables[select.from.table]
     if (dataSource === undefined) {
-      throw tableNotFoundError(select.from.table)
+      throw tableNotFoundError({ tableName: select.from.table })
     }
   } else {
     // Nested subquery - recursively resolve
@@ -236,6 +237,7 @@ async function* evaluateSelectAst(select, dataSource, tables) {
 async function* evaluateStreaming(select, dataSource, tables) {
   let rowsYielded = 0
   let rowsSkipped = 0
+  let rowIndex = 0
   const offset = select.offset ?? 0
   const limit = select.limit ?? Infinity
   if (limit <= 0) return
@@ -254,9 +256,10 @@ async function* evaluateStreaming(select, dataSource, tables) {
   }
 
   for await (const row of dataSource.getRows(hints)) {
+    rowIndex++
     // WHERE filter
     if (select.where) {
-      const pass = await evaluateExpr({ node: select.where, row, tables })
+      const pass = await evaluateExpr({ node: select.where, row, tables, rowIndex })
       if (!pass) continue
     }
 
@@ -269,6 +272,7 @@ async function* evaluateStreaming(select, dataSource, tables) {
     // SELECT projection
     /** @type {AsyncRow} */
     const outRow = {}
+    const currentRowIndex = rowIndex
     for (const col of select.columns) {
       if (col.kind === 'star') {
         for (const [key, cell] of Object.entries(row)) {
@@ -276,7 +280,7 @@ async function* evaluateStreaming(select, dataSource, tables) {
         }
       } else if (col.kind === 'derived') {
         const alias = col.alias ?? defaultDerivedAlias(col.expr)
-        outRow[alias] = () => evaluateExpr({ node: col.expr, row, tables })
+        outRow[alias] = () => evaluateExpr({ node: col.expr, row, tables, rowIndex: currentRowIndex })
       } else if (col.kind === 'aggregate') {
         throw new Error(
           'Aggregate functions require GROUP BY or will act on the whole dataset; add GROUP BY or remove aggregates'
@@ -334,9 +338,11 @@ async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGr
   /** @type {AsyncRow[]} */
   const filtered = []
 
-  for (const row of working) {
+  for (let i = 0; i < working.length; i++) {
+    const row = working[i]
+    const rowIndex = i + 1 // 1-based
     if (select.where) {
-      const passes = await evaluateExpr({ node: select.where, row, tables })
+      const passes = await evaluateExpr({ node: select.where, row, tables, rowIndex })
 
       if (!passes) {
         continue
@@ -379,10 +385,10 @@ async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGr
 
     const hasStar = select.columns.some(col => col.kind === 'star')
     if (hasStar && hasAggregate) {
-      throw unsupportedOperationError(
-        'SELECT * with aggregate functions is not supported',
-        'Replace * with specific column names when using aggregate functions.'
-      )
+      throw unsupportedOperationError({
+        operation: 'SELECT * with aggregate functions is not supported',
+        hint: 'Replace * with specific column names when using aggregate functions.',
+      })
     }
 
     for (const group of groups) {

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,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
   }
@@ -57,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
     }
@@ -76,15 +79,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 +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)
   }
 
@@ -102,38 +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 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 +183,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 +200,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 +214,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 +225,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 +260,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 +335,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 +347,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 +369,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 +380,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 +412,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 +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 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,21 +463,26 @@ 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 = []
@@ -346,28 +507,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 +539,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',
+  })
 }

package/src/execute/join.js

@@ -1,4 +1,5 @@
-import { missingClauseError, tableNotFoundError } from '../errors.js'
+import { missingClauseError } from '../parseErrors.js'
+import { tableNotFoundError } from '../executionErrors.js'
 import { evaluateExpr } from './expression.js'
 import { stringify } from './utils.js'
 
@@ -23,7 +24,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[0]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw tableNotFoundError(join.table)
+      throw tableNotFoundError({ tableName: join.table })
     }
 
     // Buffer right rows for hash index (required for hash join)
@@ -63,7 +64,7 @@ export async function executeJoins(leftSource, joins, leftTableName, tables) {
     const join = joins[i]
     const rightSource = tables[join.table]
     if (rightSource === undefined) {
-      throw tableNotFoundError(join.table)
+      throw tableNotFoundError({ tableName: join.table })
     }
 
     /** @type {AsyncRow[]} */
@@ -99,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 tableNotFoundError(lastJoin.table)
+    throw tableNotFoundError({ tableName: lastJoin.table })
   }
 
   /** @type {AsyncRow[]} */