squirreling 0.10.2 → 0.11.0

package/src/execute/join.js

@@ -1,5 +1,5 @@
 import { evaluateExpr } from '../expression/evaluate.js'
-import { stringify } from './utils.js'
+import { keyify } from './utils.js'
 import { executePlan } from './execute.js'
 
 /**
@@ -26,13 +26,12 @@ export async function* executeNestedLoopJoin(plan, context) {
     rightRows.push(row)
   }
 
-  const rightCols = rightRows.length ? rightRows[0].columns : []
-  const rightPrefixedCols = prefixColumns(rightCols, rightTable)
+  const rightPrefixedCols = rightRows.length ? prefixColumns(rightRows[0].columns, rightTable) : []
 
-  /** @type {string[] | null} */
-  let leftPrefixedCols = null
-  /** @type {Set<AsyncRow> | null} */
-  const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : null
+  /** @type {string[] | undefined} */
+  let leftPrefixedCols = undefined
+  /** @type {Set<AsyncRow> | undefined} */
+  const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
   for await (const leftRow of executePlan({ plan: plan.left, context })) {
     if (context.signal?.aborted) break
@@ -53,7 +52,7 @@ export async function* executeNestedLoopJoin(plan, context) {
 
       if (matches) {
         hasMatch = true
-        if (matchedRightRows) matchedRightRows.add(rightRow)
+        matchedRightRows?.add(rightRow)
         yield tempMerged
       }
     }
@@ -68,7 +67,7 @@ export async function* executeNestedLoopJoin(plan, context) {
   if (matchedRightRows) {
     for (const rightRow of rightRows) {
       if (!matchedRightRows.has(rightRow)) {
-        const nullLeft = createNullRow(leftPrefixedCols || [])
+        const nullLeft = createNullRow(leftPrefixedCols ?? [])
         yield mergeRows(nullLeft, rightRow, leftTable, rightTable)
       }
     }
@@ -135,7 +134,7 @@ export async function* executeHashJoin(plan, context) {
     rightRows.push(row)
   }
 
-  /** @type {Map<string, AsyncRow[]>} */
+  /** @type {Map<any, AsyncRow[]>} */
   const hashMap = new Map()
   for (const rightRow of rightRows) {
     const keyValue = await evaluateExpr({
@@ -144,11 +143,11 @@ export async function* executeHashJoin(plan, context) {
       context,
     })
     if (keyValue == null) continue
-    const keyStr = stringify(keyValue)
-    let bucket = hashMap.get(keyStr)
+    const key = keyify(keyValue)
+    let bucket = hashMap.get(key)
     if (!bucket) {
       bucket = []
-      hashMap.set(keyStr, bucket)
+      hashMap.set(key, bucket)
     }
     bucket.push(rightRow)
   }
@@ -157,10 +156,10 @@ export async function* executeHashJoin(plan, context) {
   const rightCols = rightRows.length ? rightRows[0].columns : []
   const rightPrefixedCols = prefixColumns(rightCols, rightTable)
 
-  /** @type {string[] | null} */
-  let leftPrefixedCols = null
-  /** @type {Set<AsyncRow> | null} */
-  const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : null
+  /** @type {string[] | undefined} */
+  let leftPrefixedCols
+  /** @type {Set<AsyncRow> | undefined} */
+  const matchedRightRows = plan.joinType === 'RIGHT' || plan.joinType === 'FULL' ? new Set() : undefined
 
   // Probe phase: stream left rows
   for await (const leftRow of executePlan({ plan: plan.left, context })) {
@@ -175,12 +174,12 @@ export async function* executeHashJoin(plan, context) {
       row: leftRow,
       context,
     })
-    const keyStr = stringify(keyValue)
-    const matchingRightRows = hashMap.get(keyStr)
+    const key = keyify(keyValue)
+    const matchingRightRows = hashMap.get(key)
 
     if (matchingRightRows?.length) {
       for (const rightRow of matchingRightRows) {
-        if (matchedRightRows) matchedRightRows.add(rightRow)
+        matchedRightRows?.add(rightRow)
         yield mergeRows(leftRow, rightRow, leftTable, rightTable)
       }
     } else if (plan.joinType === 'LEFT' || plan.joinType === 'FULL') {
@@ -193,7 +192,7 @@ export async function* executeHashJoin(plan, context) {
   if (matchedRightRows) {
     for (const rightRow of rightRows) {
       if (!matchedRightRows.has(rightRow)) {
-        const nullLeft = createNullRow(leftPrefixedCols || [])
+        const nullLeft = createNullRow(leftPrefixedCols ?? [])
         yield mergeRows(nullLeft, rightRow, leftTable, rightTable)
       }
     }

package/src/execute/utils.js

@@ -1,5 +1,5 @@
 /**
- * @import { AsyncCells, AsyncRow, OrderByItem, SqlPrimitive } from '../types.js'
+ * @import { AsyncRow, OrderByItem, SqlPrimitive } from '../types.js'
  */
 
 /**
@@ -76,14 +76,26 @@ export function stringify(value) {
   })
 }
 
+/**
+ * Returns a value suitable for use as a Set/Map key.
+ * Primitives are returned as-is (fast path), objects are stringified.
+ *
+ * @param {SqlPrimitive[]} values
+ * @returns {string | number | bigint | boolean}
+ */
+export function keyify(...values) {
+  if (values.length === 1 && typeof values[0] !== 'object') return values[0]
+  // Strings must be stringified to avoid collisions when joined
+  return values.map(v => typeof v === 'object' ? stringify(v) : v).join('|')
+}
+
 /**
  * Creates a stable string key for a row to enable deduplication
  *
- * @param {AsyncCells} cells
- * @returns {Promise<string>}
+ * @param {AsyncRow} row
+ * @returns {Promise<string | number | bigint | boolean>}
  */
-export async function stableRowKey(cells) {
-  const keys = Object.keys(cells).sort()
-  const values = await Promise.all(keys.map(k => cells[k]()))
-  return keys.map((k, i) => k + ':' + stringify(values[i])).join('|')
+export function stableRowKey(row) {
+  return Promise.all(row.columns.map(k => row.cells[k]()))
+    .then(values => keyify(...values))
 }

package/src/expression/alias.js

@@ -11,8 +11,9 @@
 export function derivedAlias(expr) {
   if (expr.type === 'identifier') {
     // For qualified names like 'users.name', use just the column part as alias
-    if (expr.name.includes('.')) {
-      return expr.name.split('.').pop()
+    const dotIndex = expr.name.indexOf('.')
+    if (dotIndex >= 0) {
+      return expr.name.substring(dotIndex + 1)
     }
     return expr.name
   }

package/src/expression/evaluate.js

@@ -1,10 +1,9 @@
-import { executeSelect } from '../execute/execute.js'
-import { stringify } from '../execute/utils.js'
-import { invalidContextError } from '../validation/executionErrors.js'
-import { aggregateError, argValueError, castError } from '../validation/expressionErrors.js'
+import { executeStatement } from '../execute/execute.js'
+import { keyify, stringify } from '../execute/utils.js'
+import { ArgValueError, ExecutionError } from '../validation/executionErrors.js'
 import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc } from '../validation/functions.js'
-import { unknownFunctionError } from '../validation/parseErrors.js'
-import { columnNotFoundError } from '../validation/planErrors.js'
+import { UnknownFunctionError } from '../validation/parseErrors.js'
+import { ColumnNotFoundError } from '../validation/planErrors.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
 import { applyIntervalToDate, dateTrunc, extractField } from './date.js'
@@ -46,18 +45,17 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
     }
     // Unknown identifier
-    throw columnNotFoundError({
+    throw new ColumnNotFoundError({
       columnName: node.name,
       availableColumns: row.columns,
-      positionStart: node.positionStart,
-      positionEnd: node.positionEnd,
       rowIndex,
+      ...node,
     })
   }
 
   // Scalar subquery - returns a single value
   if (node.type === 'subquery') {
-    const gen = executeSelect({ select: node.subquery, context })
+    const gen = executeStatement({ query: node.subquery, context })
     const { value } = await gen.next() // Start the generator
     gen.return(undefined) // Stop further execution
     if (!value) return null
@@ -111,15 +109,19 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         if (row.columns.includes(alias)) {
           return row.cells[alias]()
         } else {
-          throw aggregateError(node)
+          throw new ExecutionError({
+            message: `Aggregate function ${funcName} is not available in this context`,
+            ...node,
+          })
         }
       }
 
       // Apply FILTER clause if present
       let filteredRows = rows
       if (node.filter) {
+        const filterNode = node.filter
         const passes = await Promise.all(rows.map(row =>
-          evaluateExpr({ node: node.filter, row, context })
+          evaluateExpr({ node: filterNode, row, context })
         ))
         filteredRows = rows.filter((_, i) => passes[i])
       }
@@ -137,7 +139,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         if (node.distinct) {
           const seen = new Set()
           for (const v of values) {
-            if (v != null) seen.add(v)
+            if (v != null) seen.add(keyify(v))
           }
           return seen.size
         }
@@ -154,23 +156,17 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         ))
         let sum = 0
         let count = 0
-        /** @type {number | null} */
+        /** @type {SqlPrimitive} */
         let min = null
-        /** @type {number | null} */
+        /** @type {SqlPrimitive} */
         let max = null
 
         for (const raw of rawValues) {
           if (raw == null) continue
+          if (min === null || raw < min) min = raw
+          if (max === null || raw > max) max = raw
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
-
-          if (count === 0) {
-            min = num
-            max = num
-          } else {
-            if (min == null || num < min) min = num
-            if (max == null || num > max) max = num
-          }
           sum += num
           count++
         }
@@ -185,6 +181,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         const rawValues = await Promise.all(filteredRows.map(row =>
           evaluateExpr({ node: argNode, row, context })
         ))
+        let sum = 0
         /** @type {number[]} */
         const values = []
         for (const raw of rawValues) {
@@ -192,37 +189,77 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
           const num = Number(raw)
           if (!Number.isFinite(num)) continue
           values.push(num)
+          sum += num
         }
         const n = values.length
         if (n === 0) return null
         if (funcName === 'STDDEV_SAMP' && n === 1) return null
 
-        const mean = values.reduce((a, b) => a + b, 0) / n
+        const mean = sum / n
         const squaredDiffs = values.reduce((acc, val) => acc + (val - mean) ** 2, 0)
         const divisor = funcName === 'STDDEV_SAMP' ? n - 1 : n
         return Math.sqrt(squaredDiffs / divisor)
       }
 
-      if (funcName === 'JSON_ARRAYAGG') {
-        /** @type {SqlPrimitive[]} */
+      if (funcName === 'MEDIAN' || funcName === 'PERCENTILE_CONT' || funcName === 'APPROX_QUANTILE') {
+        let fraction
+        let valueNode
+        if (funcName === 'MEDIAN') {
+          fraction = 0.5
+          valueNode = argNode
+        } else if (funcName === 'PERCENTILE_CONT') {
+          fraction = Number(await evaluateExpr({ node: node.args[0], row: filteredRows[0] ?? { columns: [], cells: {} }, context }))
+          valueNode = node.args[1]
+        } else {
+          // APPROX_QUANTILE: (expression, fraction)
+          fraction = Number(await evaluateExpr({ node: node.args[1], row: filteredRows[0] ?? { columns: [], cells: {} }, context }))
+          valueNode = argNode
+        }
+        if (!Number.isFinite(fraction) || fraction < 0 || fraction > 1) {
+          throw new ExecutionError({
+            message: `${funcName}: fraction must be between 0 and 1, got ${fraction}`,
+            ...node,
+          })
+        }
+        const rawValues = await Promise.all(filteredRows.map(row =>
+          evaluateExpr({ node: valueNode, row, context })
+        ))
+        /** @type {number[]} */
         const values = []
+        for (const raw of rawValues) {
+          if (raw == null) continue
+          const num = Number(raw)
+          if (!Number.isFinite(num)) continue
+          values.push(num)
+        }
+        if (values.length === 0) return null
+        values.sort((a, b) => a - b)
+        const pos = fraction * (values.length - 1)
+        const lower = Math.floor(pos)
+        const upper = Math.ceil(pos)
+        if (lower === upper) return values[lower]
+        return values[lower] + (values[upper] - values[lower]) * (pos - lower)
+      }
+
+      if (funcName === 'JSON_ARRAYAGG') {
         if (node.distinct) {
+          /** @type {SqlPrimitive[]} */
+          const values = []
           const seen = new Set()
           for (const row of filteredRows) {
             const v = await evaluateExpr({ node: argNode, row, context })
-            const key = stringify(v)
+            const key = keyify(v)
             if (!seen.has(key)) {
               seen.add(key)
               values.push(v)
             }
           }
+          return values
         } else {
-          for (const row of filteredRows) {
-            const v = await evaluateExpr({ node: argNode, row, context })
-            values.push(v)
-          }
+          return await Promise.all(filteredRows.map(row =>
+            evaluateExpr({ node: argNode, row, context })
+          ))
         }
-        return values
       }
     }
 
@@ -258,9 +295,9 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
 
     if (funcName === 'NULLIF') {
       // NULLIF(a, b) returns null if a = b, otherwise returns a
+      const val2 = evaluateExpr({ node: node.args[1], row, rowIndex, rows, context })
       const val1 = await evaluateExpr({ node: node.args[0], row, rowIndex, rows, context })
-      const val2 = await evaluateExpr({ node: node.args[1], row, rowIndex, rows, context })
-      return val1 == val2 ? null : val1
+      return val1 == await val2 ? null : val1
     }
 
     if (funcName === 'DATE_TRUNC') {
@@ -285,7 +322,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
 
     if (funcName === 'JSON_OBJECT') {
       if (args.length % 2 !== 0) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: 'requires an even number of arguments (key-value pairs)',
           rowIndex,
@@ -297,7 +334,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         const key = args[i]
         const value = args[i + 1]
         if (key == null) {
-          throw argValueError({
+          throw new ArgValueError({
             ...node,
             message: 'key cannot be null',
             hint: 'All keys must be non-null values.',
@@ -335,7 +372,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       })
     }
 
-    if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
+    if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY' || funcName === 'JSON_EXTRACT') {
       let jsonArg = args[0]
       const pathArg = args[1]
       if (jsonArg == null || pathArg == null) return null
@@ -345,7 +382,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         try {
           jsonArg = JSON.parse(jsonArg)
         } catch {
-          throw argValueError({
+          throw new ArgValueError({
             ...node,
             message: 'invalid JSON string',
             hint: 'First argument must be valid JSON.',
@@ -354,7 +391,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
         }
       }
       if (typeof jsonArg !== 'object' || jsonArg instanceof Date) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `first argument must be JSON string or object, got ${typeof jsonArg}`,
           rowIndex,
@@ -396,7 +433,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       }
     }
 
-    throw unknownFunctionError(node)
+    throw new UnknownFunctionError(node)
   }
 
   if (node.type === 'cast') {
@@ -409,7 +446,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     }
     // Can only cast primitives to other primitive types
     if (typeof val === 'object') {
-      throw castError({ ...node, fromType: 'object', rowIndex })
+      throw new ExecutionError({ message: `Cannot CAST object to ${toType}`, rowIndex, ...node })
     }
     if (toType === 'INTEGER' || toType === 'INT') {
       const num = Number(val)
@@ -427,7 +464,6 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }
-    throw castError({ ...node, rowIndex })
   }
 
   // IN and NOT IN with value lists
@@ -442,7 +478,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   // IN with subqueries
   if (node.type === 'in') {
     const exprVal = await evaluateExpr({ node: node.expr, row, rowIndex, rows, context })
-    const results = executeSelect({ select: node.subquery, context })
+    const results = executeStatement({ query: node.subquery, context })
     for await (const resRow of results) {
       const value = await resRow.cells[resRow.columns[0]]()
       if (exprVal == value) return true
@@ -452,11 +488,11 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
 
   // EXISTS and NOT EXISTS with subqueries
   if (node.type === 'exists') {
-    const results = await executeSelect({ select: node.subquery, context }).next()
+    const results = await executeStatement({ query: node.subquery, context }).next()
     return results.done === false
   }
   if (node.type === 'not exists') {
-    const results = await executeSelect({ select: node.subquery, context }).next()
+    const results = await executeStatement({ query: node.subquery, context }).next()
     return results.done === true
   }
 
@@ -467,17 +503,9 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
 
     // 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, rowIndex, rows, context })
-        conditionResult = caseValue == whenValue
-      } else {
-        // Searched CASE: evaluate condition as boolean
-        conditionResult = await evaluateExpr({ node: whenClause.condition, row, rowIndex, rows, context })
-      }
-
-      if (conditionResult) {
+      const whenValue = await evaluateExpr({ node: whenClause.condition, row, rowIndex, rows, context })
+      // compare caseValue with condition or evaluate as boolean
+      if (caseValue !== undefined ? caseValue == whenValue : whenValue) {
         return evaluateExpr({ node: whenClause.result, row, rowIndex, rows, context })
       }
     }
@@ -492,12 +520,10 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
   // 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,
+    throw new ExecutionError({
+      message: 'INTERVAL can only be used with date arithmetic (+ or -)',
       rowIndex,
+      ...node,
     })
   }
 

package/src/expression/math.js

@@ -122,4 +122,6 @@ export function evaluateMathFunc({ funcName, args }) {
   if (funcName === 'RADIANS') {
     return Number(val) * Math.PI / 180
   }
+
+  throw new Error(`Unsupported math function: ${funcName}`)
 }

package/src/expression/regexp.js

@@ -1,4 +1,4 @@
-import { argValueError } from '../validation/expressionErrors.js'
+import { ArgValueError } from '../validation/executionErrors.js'
 
 /**
  * @import { FunctionNode, RegExpFunction, SqlPrimitive } from '../types.js'
@@ -11,11 +11,11 @@ import { argValueError } from '../validation/expressionErrors.js'
  * @param {RegExpFunction} options.funcName
  * @param {FunctionNode} options.node
  * @param {SqlPrimitive[]} options.args - Function arguments
- * @param {number} options.rowIndex - Row index for error reporting
+ * @param {number} [options.rowIndex] - Row index for error reporting
  * @returns {SqlPrimitive}
  */
 export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
-  if (funcName === 'REGEXP_SUBSTR') {
+  if (funcName === 'REGEXP_SUBSTR' || funcName === 'REGEXP_EXTRACT') {
     const str = args[0]
     const pattern = args[1]
     if (str == null || pattern == null) return null
@@ -27,7 +27,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     if (args.length >= 3 && args[2] != null) {
       position = Number(args[2])
       if (!Number.isInteger(position) || position < 1) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `position must be a positive integer, got ${args[2]}`,
           hint: 'SQL uses 1-based indexing.',
@@ -41,7 +41,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     if (args.length >= 4 && args[3] != null) {
       occurrence = Number(args[3])
       if (!Number.isInteger(occurrence) || occurrence < 1) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `occurrence must be a positive integer, got ${args[3]}`,
           hint: 'SQL uses 1-based indexing.',
@@ -55,7 +55,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     try {
       regex = new RegExp(patternStr, 'g')
     } catch (/** @type {any} */ error) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: `invalid regex pattern: ${error.message}`,
         rowIndex,
@@ -92,7 +92,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     if (args.length >= 4 && args[3] != null) {
       position = Number(args[3])
       if (!Number.isInteger(position) || position < 1) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `position must be a positive integer, got ${args[3]}`,
           hint: 'SQL uses 1-based indexing.',
@@ -106,7 +106,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     if (args.length >= 5 && args[4] != null) {
       occurrence = Number(args[4])
       if (!Number.isInteger(occurrence) || occurrence < 0) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `occurrence must be a non-negative integer, got ${args[4]}`,
           hint: 'Use 0 to replace all occurrences.',
@@ -120,7 +120,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     try {
       regex = new RegExp(patternStr, 'g')
     } catch (/** @type {any} */ error) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: `invalid regex pattern: ${error.message}`,
         rowIndex,
@@ -144,4 +144,6 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
     })
     return prefix + result
   }
+
+  throw new Error(`Unsupported regexp function: ${funcName}`)
 }

package/src/expression/strings.js

@@ -1,9 +1,9 @@
+import { ArgValueError } from '../validation/executionErrors.js'
+
 /**
  * @import { FunctionNode, SqlPrimitive, StringFunc } from '../types.js'
  */
 
-import { argValueError } from '../validation/expressionErrors.js'
-
 /**
  * Evaluate a string function
  *
@@ -11,7 +11,7 @@ import { argValueError } from '../validation/expressionErrors.js'
  * @param {StringFunc} options.funcName
  * @param {FunctionNode} options.node
  * @param {SqlPrimitive[]} options.args - Function arguments
- * @param {number} options.rowIndex - Row index for error reporting
+ * @param {number} [options.rowIndex] - Row index for error reporting
  * @returns {SqlPrimitive}
  */
 export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
@@ -19,7 +19,7 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     // Returns NULL if any argument is NULL
     if (args.some(a => a == null)) return null
     if (args.some(a => typeof a === 'object')) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: 'does not support object arguments',
         hint: 'Use CAST to convert objects to strings first.',
@@ -49,7 +49,7 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
   if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
     const start = Number(args[1])
     if (!Number.isInteger(start) || start < 1) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: `start position must be a positive integer, got ${args[1]}`,
         hint: 'SQL uses 1-based indexing.',
@@ -61,7 +61,7 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     if (args.length === 3) {
       const len = Number(args[2])
       if (!Number.isInteger(len) || len < 0) {
-        throw argValueError({
+        throw new ArgValueError({
           ...node,
           message: `length must be a non-negative integer, got ${args[2]}`,
           hint: 'SQL uses 1-based indexing.',
@@ -90,7 +90,7 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     if (n == null) return null
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: `length must be a non-negative integer, got ${n}`,
         hint: 'SQL uses 1-based indexing.',
@@ -105,7 +105,7 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     if (n == null) return null
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
-      throw argValueError({
+      throw new ArgValueError({
         ...node,
         message: `length must be a non-negative integer, got ${n}`,
         hint: 'SQL uses 1-based indexing.',
@@ -116,10 +116,12 @@ export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
     return str.substring(str.length - len)
   }
 
-  if (funcName === 'INSTR') {
+  if (funcName === 'INSTR' || funcName === 'POSITION' || funcName === 'STRPOS') {
     const search = args[1]
     if (search == null) return null
     // INSTR returns 1-based position, 0 if not found
     return str.indexOf(String(search)) + 1
   }
+
+  throw new Error(`Unsupported string function: ${funcName}`)
 }