squirreling 0.4.7 → 0.5.0

package/src/execute/math.js

@@ -0,0 +1,165 @@
+/**
+ * @import { SqlPrimitive } from '../types.js'
+ */
+import { argCountError } from '../validationErrors.js'
+
+/**
+ * Evaluate a math function
+ *
+ * @param {Object} options
+ * @param {string} options.funcName - Uppercase function name
+ * @param {SqlPrimitive[]} options.args - Function arguments
+ * @param {number} options.positionStart - Start position in query
+ * @param {number} options.positionEnd - End position in query
+ * @param {number} [options.rowNumber] - 1-based row number for error reporting
+ * @returns {SqlPrimitive} Result
+ */
+export function evaluateMathFunc({ funcName, args, positionStart, positionEnd, rowNumber }) {
+  if (funcName === 'FLOOR') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'FLOOR',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.floor(Number(val))
+  }
+
+  if (funcName === 'CEIL' || funcName === 'CEILING') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName,
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.ceil(Number(val))
+  }
+
+  if (funcName === 'ABS') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'ABS',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.abs(Number(val))
+  }
+
+  if (funcName === 'MOD') {
+    if (args.length !== 2) {
+      throw argCountError({
+        funcName: 'MOD',
+        expected: 2,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const dividend = args[0]
+    const divisor = args[1]
+    if (dividend == null || divisor == null) return null
+    return Number(dividend) % Number(divisor)
+  }
+
+  if (funcName === 'EXP') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'EXP',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.exp(Number(val))
+  }
+
+  if (funcName === 'LN') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'LN',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.log(Number(val))
+  }
+
+  if (funcName === 'LOG10') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'LOG10',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.log10(Number(val))
+  }
+
+  if (funcName === 'POWER') {
+    if (args.length !== 2) {
+      throw argCountError({
+        funcName: 'POWER',
+        expected: 2,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const base = args[0]
+    const exponent = args[1]
+    if (base == null || exponent == null) return null
+    return Number(base) ** Number(exponent)
+  }
+
+  if (funcName === 'SQRT') {
+    if (args.length !== 1) {
+      throw argCountError({
+        funcName: 'SQRT',
+        expected: 1,
+        received: args.length,
+        positionStart,
+        positionEnd,
+        rowNumber,
+      })
+    }
+    const val = args[0]
+    if (val == null) return null
+    return Math.sqrt(Number(val))
+  }
+
+  return undefined
+}

package/src/execute/utils.js

@@ -134,6 +134,9 @@ export function defaultDerivedAlias(expr) {
   if (expr.type === 'function') {
     return expr.name.toLowerCase() + '_' + expr.args.map(defaultDerivedAlias).join('_')
   }
+  if (expr.type === 'interval') {
+    return `interval_${expr.value}_${expr.unit.toLowerCase()}`
+  }
   return 'expr'
 }
 

package/src/executionErrors.js

@@ -0,0 +1,62 @@
+// ============================================================================
+// EXECUTION ERRORS - Issues during query execution
+// ============================================================================
+
+/**
+ * Structured execution error with position range and optional row number.
+ */
+export class ExecutionError extends Error {
+  /**
+   * @param {string} message - Human-readable error message
+   * @param {number} positionStart - Start position (0-based character offset)
+   * @param {number} positionEnd - End position (exclusive, 0-based character offset)
+   * @param {number} [rowNumber] - 1-based row number where error occurred
+   */
+  constructor(message, positionStart, positionEnd, rowNumber) {
+    const rowSuffix = rowNumber != null ? ` (row ${rowNumber})` : ''
+    super(message + rowSuffix)
+    this.name = 'ExecutionError'
+    this.positionStart = positionStart
+    this.positionEnd = positionEnd
+    this.rowNumber = rowNumber
+  }
+}
+
+/**
+ * Error for missing table.
+ *
+ * @param {Object} options
+ * @param {string} options.tableName - The missing table name
+ * @returns {Error}
+ */
+export function tableNotFoundError({ tableName }) {
+  return new Error(`Table "${tableName}" not found. Check spelling or add it to the tables parameter.`)
+}
+
+/**
+ * Error for invalid context (e.g., INTERVAL without date arithmetic).
+ *
+ * @param {Object} options
+ * @param {string} options.item - What was used incorrectly
+ * @param {string} options.validContext - Where it can be used
+ * @param {number} options.positionStart - Start position in query
+ * @param {number} options.positionEnd - End position in query
+ * @param {number} [options.rowNumber] - 1-based row number where error occurred
+ * @returns {ExecutionError}
+ */
+export function invalidContextError({ item, validContext, positionStart, positionEnd, rowNumber }) {
+  return new ExecutionError(`${item} can only be used with ${validContext}`, positionStart, positionEnd, rowNumber)
+}
+
+/**
+ * Error for unsupported operation combinations.
+ *
+ * @param {Object} options
+ * @param {string} options.operation - The unsupported operation
+ * @param {string} [options.hint] - How to fix it
+ * @returns {Error}
+ */
+export function unsupportedOperationError({ operation, hint }) {
+  const suffix = hint ? `. ${hint}` : ''
+  return new Error(`${operation}${suffix}`)
+}

package/src/index.js

@@ -2,3 +2,4 @@ export { executeSql } from './execute/execute.js'
 export { parseSql } from './parse/parse.js'
 export { collect } from './execute/utils.js'
 export { cachedDataSource } from './backend/dataSource.js'
+export { ParseError } from './parseErrors.js'

package/src/parse/comparison.js

@@ -1,6 +1,7 @@
+import { syntaxError } from '../parseErrors.js'
 import { isBinaryOp } from '../validation.js'
 import { parseAdditive, parseExpression, parseSubquery } from './expression.js'
-import { consume, current, expect, match, peekToken } from './state.js'
+import { consume, current, expect, lastPosition, match, peekToken } from './state.js'
 
 /**
  * @import { ExprNode, ParserState } from '../types.js'
@@ -25,6 +26,8 @@ export function parseComparison(state) {
         type: 'unary',
         op: 'IS NOT NULL',
         argument: left,
+        positionStart: left.positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     expect(state, 'keyword', 'NULL')
@@ -32,6 +35,8 @@ export function parseComparison(state) {
       type: 'unary',
       op: 'IS NULL',
       argument: left,
+      positionStart: left.positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -39,6 +44,7 @@ export function parseComparison(state) {
   if (tok.type === 'keyword' && tok.value === 'NOT') {
     const nextTok = peekToken(state, 1)
     if (nextTok.type === 'keyword' && nextTok.value === 'LIKE') {
+      const notPositionStart = tok.positionStart
       consume(state) // NOT
       consume(state) // LIKE
       const right = parseAdditive(state)
@@ -50,7 +56,11 @@ export function parseComparison(state) {
           op: 'LIKE',
           left,
           right,
+          positionStart: left.positionStart,
+          positionEnd: right.positionEnd,
         },
+        positionStart: notPositionStart,
+        positionEnd: right.positionEnd,
       }
     }
   }
@@ -63,6 +73,8 @@ export function parseComparison(state) {
       op: 'LIKE',
       left,
       right,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
 
@@ -70,6 +82,7 @@ export function parseComparison(state) {
   if (tok.type === 'keyword' && tok.value === 'NOT') {
     const nextTok = peekToken(state, 1)
     if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
+      const notPositionStart = tok.positionStart
       consume(state) // NOT
       consume(state) // BETWEEN
       const lower = parseAdditive(state)
@@ -79,8 +92,10 @@ export function parseComparison(state) {
       return {
         type: 'binary',
         op: 'OR',
-        left: { type: 'binary', op: '<', left, right: lower },
-        right: { type: 'binary', op: '>', left, right: upper },
+        left: { type: 'binary', op: '<', left, right: lower, positionStart: left.positionStart, positionEnd: lower.positionEnd },
+        right: { type: 'binary', op: '>', left, right: upper, positionStart: left.positionStart, positionEnd: upper.positionEnd },
+        positionStart: notPositionStart,
+        positionEnd: upper.positionEnd,
       }
     }
   }
@@ -94,8 +109,10 @@ export function parseComparison(state) {
     return {
       type: 'binary',
       op: 'AND',
-      left: { type: 'binary', op: '>=', left, right: lower },
-      right: { type: 'binary', op: '<=', left, right: upper },
+      left: { type: 'binary', op: '>=', left, right: lower, positionStart: left.positionStart, positionEnd: lower.positionEnd },
+      right: { type: 'binary', op: '<=', left, right: upper, positionStart: left.positionStart, positionEnd: upper.positionEnd },
+      positionStart: left.positionStart,
+      positionEnd: upper.positionEnd,
     }
   }
 
@@ -103,6 +120,7 @@ export function parseComparison(state) {
   if (tok.type === 'keyword' && tok.value === 'NOT') {
     const nextTok = peekToken(state, 1)
     if (nextTok.type === 'keyword' && nextTok.value === 'IN') {
+      const notPositionStart = tok.positionStart
       consume(state) // NOT
       consume(state) // IN
 
@@ -110,12 +128,13 @@ export function parseComparison(state) {
       // parseSubquery expects to consume the opening paren itself
       const parenTok = current(state)
       if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-        throw new Error('Expected ( after IN')
+        throw syntaxError({ expected: '(', received: `"${parenTok.value}"`, positionStart: parenTok.positionStart, positionEnd: parenTok.positionEnd, after: 'IN' })
       }
       const peekTok = peekToken(state, 1)
       if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
         // Subquery - let parseSubquery handle the parens
         const subquery = parseSubquery(state)
+        const positionEnd = lastPosition(state)
         return {
           type: 'unary',
           op: 'NOT',
@@ -123,7 +142,11 @@ export function parseComparison(state) {
             type: 'in',
             expr: left,
             subquery,
+            positionStart: left.positionStart,
+            positionEnd,
           },
+          positionStart: notPositionStart,
+          positionEnd,
         }
       } else {
         // Parse list of values - we handle the parens
@@ -135,6 +158,7 @@ export function parseComparison(state) {
           if (!match(state, 'comma')) break
         }
         expect(state, 'paren', ')')
+        const positionEnd = lastPosition(state)
         return {
           type: 'unary',
           op: 'NOT',
@@ -142,7 +166,11 @@ export function parseComparison(state) {
             type: 'in valuelist',
             expr: left,
             values,
+            positionStart: left.positionStart,
+            positionEnd,
           },
+          positionStart: notPositionStart,
+          positionEnd,
         }
       }
     }
@@ -155,7 +183,7 @@ export function parseComparison(state) {
     // parseSubquery expects to consume the opening paren itself
     const parenTok = current(state)
     if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-      throw new Error('Expected ( after IN')
+      throw syntaxError({ expected: '(', received: `"${parenTok.value}"`, positionStart: parenTok.positionStart, positionEnd: parenTok.positionEnd, after: 'IN' })
     }
     const peekTok = peekToken(state, 1)
     if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
@@ -165,6 +193,8 @@ export function parseComparison(state) {
         type: 'in',
         expr: left,
         subquery,
+        positionStart: left.positionStart,
+        positionEnd: lastPosition(state),
       }
     } else {
       // Parse list of values - we handle the parens
@@ -180,6 +210,8 @@ export function parseComparison(state) {
         type: 'in valuelist',
         expr: left,
         values,
+        positionStart: left.positionStart,
+        positionEnd: lastPosition(state),
       }
     }
   }
@@ -192,6 +224,8 @@ export function parseComparison(state) {
       op: tok.value,
       left,
       right,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
   }