squirreling 0.7.9 → 0.8.0

package/src/{execute → expression}/math.js

@@ -11,150 +11,115 @@
  * @returns {SqlPrimitive}
  */
 export function evaluateMathFunc({ funcName, args }) {
-  if (funcName === 'FLOOR') {
-    const val = args[0]
-    if (val == null) return null
-    return Math.floor(Number(val))
+  // No args
+  if (funcName === 'PI') {
+    return Math.PI
   }
 
-  if (funcName === 'CEIL' || funcName === 'CEILING') {
-    const val = args[0]
-    if (val == null) return null
-    return Math.ceil(Number(val))
+  if (funcName === 'RAND' || funcName === 'RANDOM') {
+    return Math.random()
+  }
+
+  // Two args
+  if (funcName === 'MOD') {
+    const [dividend, divisor] = args
+    if (dividend == null || divisor == null) return null
+    return Number(dividend) % Number(divisor)
+  }
+
+  if (funcName === 'POWER') {
+    const [base, exponent] = args
+    if (base == null || exponent == null) return null
+    return Number(base) ** Number(exponent)
+  }
+
+  if (funcName === 'ATAN2') {
+    const [y, x] = args
+    if (y == null || x == null) return null
+    return Math.atan2(Number(y), Number(x))
+  }
+
+  // One arg
+  const [val] = args
+  if (val == null) return null
+
+  if (funcName === 'ATAN') {
+    if (args.length === 1) {
+      return Math.atan(Number(val))
+    } else {
+      const [y, x] = args
+      if (y == null || x == null) return null
+      return Math.atan2(Number(y), Number(x))
+    }
   }
 
   if (funcName === 'ROUND') {
-    const val = args[0]
-    if (val == null) return null
     const decimals = args[1] ?? 0
-    if (decimals == null) return null
     const multiplier = 10 ** Number(decimals)
     return Math.round(Number(val) * multiplier) / multiplier
   }
 
+  if (funcName === 'FLOOR') {
+    return Math.floor(Number(val))
+  }
+
+  if (funcName === 'CEIL' || funcName === 'CEILING') {
+    return Math.ceil(Number(val))
+  }
+
   if (funcName === 'ABS') {
-    const val = args[0]
-    if (val == null) return null
     return Math.abs(Number(val))
   }
 
   if (funcName === 'SIGN') {
-    const val = args[0]
-    if (val == null) return null
     return Math.sign(Number(val))
   }
 
-  if (funcName === 'MOD') {
-    const dividend = args[0]
-    const divisor = args[1]
-    if (dividend == null || divisor == null) return null
-    return Number(dividend) % Number(divisor)
-  }
-
   if (funcName === 'EXP') {
-    const val = args[0]
-    if (val == null) return null
     return Math.exp(Number(val))
   }
 
   if (funcName === 'LN') {
-    const val = args[0]
-    if (val == null) return null
     return Math.log(Number(val))
   }
 
   if (funcName === 'LOG10') {
-    const val = args[0]
-    if (val == null) return null
     return Math.log10(Number(val))
   }
 
-  if (funcName === 'POWER') {
-    const base = args[0]
-    const exponent = args[1]
-    if (base == null || exponent == null) return null
-    return Number(base) ** Number(exponent)
-  }
-
   if (funcName === 'SQRT') {
-    const val = args[0]
-    if (val == null) return null
     return Math.sqrt(Number(val))
   }
 
   if (funcName === 'SIN') {
-    const val = args[0]
-    if (val == null) return null
     return Math.sin(Number(val))
   }
 
   if (funcName === 'COS') {
-    const val = args[0]
-    if (val == null) return null
     return Math.cos(Number(val))
   }
 
   if (funcName === 'TAN') {
-    const val = args[0]
-    if (val == null) return null
     return Math.tan(Number(val))
   }
 
   if (funcName === 'COT') {
-    const val = args[0]
-    if (val == null) return null
     return 1 / Math.tan(Number(val))
   }
 
   if (funcName === 'ASIN') {
-    const val = args[0]
-    if (val == null) return null
     return Math.asin(Number(val))
   }
 
   if (funcName === 'ACOS') {
-    const val = args[0]
-    if (val == null) return null
     return Math.acos(Number(val))
   }
 
-  if (funcName === 'ATAN') {
-    if (args.length === 1) {
-      const val = args[0]
-      if (val == null) return null
-      return Math.atan(Number(val))
-    } else {
-      const y = args[0]
-      const x = args[1]
-      if (y == null || x == null) return null
-      return Math.atan2(Number(y), Number(x))
-    }
-  }
-
-  if (funcName === 'ATAN2') {
-    const y = args[0]
-    const x = args[1]
-    if (y == null || x == null) return null
-    return Math.atan2(Number(y), Number(x))
-  }
-
   if (funcName === 'DEGREES') {
-    const val = args[0]
-    if (val == null) return null
     return Number(val) * 180 / Math.PI
   }
 
   if (funcName === 'RADIANS') {
-    const val = args[0]
-    if (val == null) return null
     return Number(val) * Math.PI / 180
   }
-
-  if (funcName === 'PI') {
-    return Math.PI
-  }
-
-  if (funcName === 'RAND' || funcName === 'RANDOM') {
-    return Math.random()
-  }
 }

package/src/{execute → expression}/regexp.js

@@ -13,7 +13,7 @@ import { argValueError } from '../validationErrors.js'
  * @param {number} [options.positionStart] - Start position in SQL string for error reporting
  * @param {number} [options.positionEnd] - End position in SQL string for error reporting
  * @param {number} [options.rowIndex] - Row number for error reporting
- * @returns {SqlPrimitive} Result
+ * @returns {SqlPrimitive}
  */
 export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd, rowIndex }) {
   if (funcName === 'REGEXP_SUBSTR') {
@@ -34,7 +34,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
           positionStart,
           positionEnd,
           hint: 'SQL uses 1-based indexing.',
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
     }
@@ -49,7 +49,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
           message: `occurrence must be a positive integer, got ${args[3]}`,
           positionStart,
           positionEnd,
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
     }
@@ -64,7 +64,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
         message: `invalid regex pattern: ${error.message}`,
         positionStart,
         positionEnd,
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
 
@@ -104,7 +104,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
           positionStart,
           positionEnd,
           hint: 'SQL uses 1-based indexing.',
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
     }
@@ -120,7 +120,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
           positionStart,
           positionEnd,
           hint: 'Use 0 to replace all occurrences.',
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
     }
@@ -135,7 +135,7 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
         message: `invalid regex pattern: ${error.message}`,
         positionStart,
         positionEnd,
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
 

package/src/{execute → expression}/strings.js

@@ -13,23 +13,11 @@ import { argValueError } from '../validationErrors.js'
  * @param {number} [options.positionStart] - Start position for error reporting
  * @param {number} [options.positionEnd] - End position for error reporting
  * @param {number} [options.rowIndex] - Row index for error reporting
- * @returns {SqlPrimitive} Result
+ * @returns {SqlPrimitive}
  */
 export function evaluateStringFunc({ funcName, args, positionStart, positionEnd, rowIndex }) {
-  if (funcName === 'UPPER') {
-    const val = args[0]
-    if (val == null) return null
-    return String(val).toUpperCase()
-  }
-
-  if (funcName === 'LOWER') {
-    const val = args[0]
-    if (val == null) return null
-    return String(val).toLowerCase()
-  }
-
   if (funcName === 'CONCAT') {
-    // SQL CONCAT returns NULL if any argument is NULL
+    // Returns NULL if any argument is NULL
     if (args.some(a => a == null)) return null
     if (args.some(a => typeof a === 'object')) {
       throw argValueError({
@@ -38,22 +26,30 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
         positionStart,
         positionEnd,
         hint: 'Use CAST to convert objects to strings first.',
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
     return args.map(a => String(a)).join('')
   }
 
+  // String first arg
+  const [val] = args
+  if (val == null) return null
+  const str = String(val)
+
+  if (funcName === 'UPPER') {
+    return str.toUpperCase()
+  }
+
+  if (funcName === 'LOWER') {
+    return str.toLowerCase()
+  }
+
   if (funcName === 'LENGTH') {
-    const val = args[0]
-    if (val == null) return null
-    return String(val).length
+    return str.length
   }
 
   if (funcName === 'SUBSTRING' || funcName === 'SUBSTR') {
-    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 argValueError({
@@ -62,7 +58,7 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
         positionStart,
         positionEnd,
         hint: 'SQL uses 1-based indexing.',
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
     // SQL uses 1-based indexing
@@ -75,33 +71,29 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
           message: `length must be a non-negative integer, got ${args[2]}`,
           positionStart,
           positionEnd,
-          rowNumber: rowIndex,
+          rowIndex,
         })
       }
-      return strVal.substring(startIdx, startIdx + len)
+      return str.substring(startIdx, startIdx + len)
     }
-    return strVal.substring(startIdx)
+    return str.substring(startIdx)
   }
 
   if (funcName === 'TRIM') {
-    const val = args[0]
-    if (val == null) return null
-    return String(val).trim()
+    return str.trim()
   }
 
   if (funcName === 'REPLACE') {
-    const str = args[0]
     const searchStr = args[1]
     const replaceStr = args[2]
     // SQL REPLACE returns NULL if any argument is NULL
-    if (str == null || searchStr == null || replaceStr == null) return null
-    return String(str).replaceAll(String(searchStr), String(replaceStr))
+    if (searchStr == null || replaceStr == null) return null
+    return str.replaceAll(String(searchStr), String(replaceStr))
   }
 
   if (funcName === 'LEFT') {
-    const str = args[0]
     const n = args[1]
-    if (str == null || n == null) return null
+    if (n == null) return null
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
       throw argValueError({
@@ -109,16 +101,15 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
         message: `length must be a non-negative integer, got ${n}`,
         positionStart,
         positionEnd,
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
-    return String(str).substring(0, len)
+    return str.substring(0, len)
   }
 
   if (funcName === 'RIGHT') {
-    const str = args[0]
     const n = args[1]
-    if (str == null || n == null) return null
+    if (n == null) return null
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
       throw argValueError({
@@ -126,20 +117,17 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
         message: `length must be a non-negative integer, got ${n}`,
         positionStart,
         positionEnd,
-        rowNumber: rowIndex,
+        rowIndex,
       })
     }
-    const strVal = String(str)
-    if (len >= strVal.length) return strVal
-    return strVal.substring(strVal.length - len)
+    if (len >= str.length) return str
+    return str.substring(str.length - len)
   }
 
   if (funcName === 'INSTR') {
-    const str = args[0]
     const search = args[1]
-    if (str == null || search == null) return null
+    if (search == null) return null
     // INSTR returns 1-based position, 0 if not found
-    const pos = String(str).indexOf(String(search))
-    return pos === -1 ? 0 : pos + 1
+    return str.indexOf(String(search)) + 1
   }
 }

package/src/index.d.ts

@@ -1,5 +1,19 @@
 import type { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ParseSqlOptions, SelectStatement, SqlPrimitive, Token } from './types.js'
-export type { AsyncCells, AsyncDataSource, AsyncRow, ExprNode, ParseSqlOptions, SelectStatement, SqlPrimitive, Token, UserDefinedFunction } from './types.js'
+export type {
+  AsyncCells,
+  AsyncDataSource,
+  AsyncRow,
+  ExecuteSqlOptions,
+  ExprNode,
+  ParseSqlOptions,
+  QueryPlan,
+  ScanOptions,
+  ScanResults,
+  SelectStatement,
+  SqlPrimitive,
+  Token,
+  UserDefinedFunction,
+} from './types.js'
 
 /**
  * Executes a SQL SELECT query against an array of data rows

package/src/parse/expression.js

@@ -14,56 +14,6 @@ import { consume, current, expect, expectIdentifier, lastPosition, match, peekTo
  * @import { ExprNode, IntervalNode, ParserState, SelectStatement, WhenClause } from '../types.js'
  */
 
-/**
- * @param {ParserState} state
- * @returns {IntervalNode}
- */
-function parseInterval(state) {
-  const { positionStart } = current(state)
-  consume(state) // INTERVAL
-
-  // Handle optional negative sign
-  let sign = 1
-  const signTok = current(state)
-  if (signTok.type === 'operator' && signTok.value === '-') {
-    consume(state)
-    sign = -1
-  }
-
-  // Get value (number or quoted string)
-  const valueTok = current(state)
-  /** @type {number} */
-  let value
-  if (valueTok.type === 'number') {
-    consume(state)
-    value = sign * Number(valueTok.numericValue)
-  } else if (valueTok.type === 'string') {
-    consume(state)
-    const parsed = parseFloat(valueTok.value)
-    if (isNaN(parsed)) {
-      throw invalidLiteralError({ type: 'interval value', value: valueTok.value, positionStart: valueTok.positionStart, positionEnd: valueTok.positionEnd })
-    }
-    value = sign * parsed
-  } else {
-    throw syntaxError({ expected: 'interval value (number)', received: `"${valueTok.value}"`, positionStart: valueTok.positionStart, positionEnd: valueTok.positionEnd })
-  }
-
-  // Get unit keyword
-  const unitTok = current(state)
-  if (unitTok.type !== 'keyword' || !isIntervalUnit(unitTok.value)) {
-    throw invalidLiteralError({
-      type: 'interval unit',
-      value: unitTok.value,
-      positionStart: unitTok.positionStart,
-      positionEnd: unitTok.positionEnd,
-      validValues: 'DAY, MONTH, YEAR, HOUR, MINUTE, SECOND',
-    })
-  }
-  consume(state)
-
-  return { type: 'interval', value, unit: unitTok.value, positionStart, positionEnd: lastPosition(state) }
-}
-
 /**
  * @param {ParserState} state
  * @returns {ExprNode}
@@ -422,3 +372,45 @@ export function parseSubquery(state) {
   expect(state, 'paren', ')')
   return query
 }
+
+/**
+ * @param {ParserState} state
+ * @returns {IntervalNode}
+ */
+function parseInterval(state) {
+  const { positionStart } = current(state)
+  consume(state) // INTERVAL
+
+  // Get value (number or quoted string)
+  const valueTok = current(state)
+  /** @type {number} */
+  let value
+  if (valueTok.type === 'number') {
+    consume(state)
+    value = Number(valueTok.numericValue)
+  } else if (valueTok.type === 'string') {
+    consume(state)
+    const parsed = parseFloat(valueTok.value)
+    if (isNaN(parsed)) {
+      throw invalidLiteralError({ type: 'interval value', value: valueTok.value, positionStart: valueTok.positionStart, positionEnd: valueTok.positionEnd })
+    }
+    value = parsed
+  } else {
+    throw syntaxError({ expected: 'interval value (number)', received: `"${valueTok.value}"`, positionStart: valueTok.positionStart, positionEnd: valueTok.positionEnd })
+  }
+
+  // Get unit keyword
+  const unitTok = current(state)
+  if (unitTok.type !== 'keyword' || !isIntervalUnit(unitTok.value)) {
+    throw invalidLiteralError({
+      type: 'interval unit',
+      value: unitTok.value,
+      positionStart: unitTok.positionStart,
+      positionEnd: unitTok.positionEnd,
+      validValues: 'DAY, MONTH, YEAR, HOUR, MINUTE, SECOND',
+    })
+  }
+  consume(state)
+
+  return { type: 'interval', value, unit: unitTok.value, positionStart, positionEnd: lastPosition(state) }
+}

package/src/parse/joins.js

@@ -1,9 +1,13 @@
 import { parseExpression } from './expression.js'
 import { parseTableAlias } from './parse.js'
 import { consume, current, expect, expectIdentifier, match } from './state.js'
+import { expectNoAggregate } from '../validation.js'
+
+/**
+ * @import { ExprNode, JoinClause, JoinType, ParserState } from '../types.js'
+ */
 
 /**
- * @import { JoinClause, JoinType, ParserState } from '../types.js'
  * @param {ParserState} state
  * @returns {JoinClause[]}
  */
@@ -24,21 +28,15 @@ export function parseJoins(state) {
         joinType = 'INNER'
       } else if (tok.value === 'LEFT') {
         consume(state)
-        if (match(state, 'keyword', 'OUTER')) {
-          // LEFT OUTER JOIN
-        }
+        match(state, 'keyword', 'OUTER') // LEFT OUTER JOIN
         joinType = 'LEFT'
       } else if (tok.value === 'RIGHT') {
         consume(state)
-        if (match(state, 'keyword', 'OUTER')) {
-          // RIGHT OUTER JOIN
-        }
+        match(state, 'keyword', 'OUTER') // RIGHT OUTER JOIN
         joinType = 'RIGHT'
       } else if (tok.value === 'FULL') {
         consume(state)
-        if (match(state, 'keyword', 'OUTER')) {
-          // FULL OUTER JOIN
-        }
+        match(state, 'keyword', 'OUTER') // FULL OUTER JOIN
         joinType = 'FULL'
       } else if (tok.value === 'POSITIONAL') {
         consume(state)
@@ -65,11 +63,12 @@ export function parseJoins(state) {
     const tableAlias = parseTableAlias(state)
 
     // Parse ON condition (not for POSITIONAL joins)
-    /** @type {import('../types.js').ExprNode | undefined} */
+    /** @type {ExprNode | undefined} */
     let condition
     if (joinType !== 'POSITIONAL') {
       expect(state, 'keyword', 'ON')
       condition = parseExpression(state)
+      expectNoAggregate(condition, 'JOIN ON')
     }
 
     joins.push({

package/src/parse/parse.js

@@ -1,9 +1,9 @@
 import { parseExpression } from './expression.js'
-import { tokenizeSql } from './tokenize.js'
-import { consume, current, expect, expectIdentifier, match, parseError, peekToken } from './state.js'
 import { parseJoins } from './joins.js'
+import { consume, current, expect, expectIdentifier, match, parseError, peekToken } from './state.js'
+import { tokenizeSql } from './tokenize.js'
 import { duplicateCTEError } from '../parseErrors.js'
-import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE, isKnownFunction } from '../validation.js'
+import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE, expectNoAggregate, isKnownFunction } from '../validation.js'
 
 /**
  * @import { CTEDefinition, ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectStatement, SelectColumn, WithClause } from '../types.js'
@@ -266,12 +266,14 @@ export function parseSelectInternal(state) {
 
   if (match(state, 'keyword', 'WHERE')) {
     where = parseExpression(state)
+    expectNoAggregate(where, 'WHERE')
   }
 
   if (match(state, 'keyword', 'GROUP')) {
     expect(state, 'keyword', 'BY')
     while (true) {
       const expr = parseExpression(state)
+      expectNoAggregate(expr, 'GROUP BY')
       groupBy.push(expr)
       if (!match(state, 'comma')) break
     }
@@ -325,6 +327,9 @@ export function parseSelectInternal(state) {
     if (!Number.isFinite(n)) {
       throw parseError(state, 'valid LIMIT value')
     }
+    if (n < 0) {
+      throw parseError(state, 'non-negative LIMIT value')
+    }
     limit = n
 
     if (match(state, 'keyword', 'OFFSET')) {
@@ -337,6 +342,9 @@ export function parseSelectInternal(state) {
       if (!Number.isFinite(off)) {
         throw parseError(state, 'valid OFFSET value')
       }
+      if (off < 0) {
+        throw parseError(state, 'non-negative OFFSET value')
+      }
       offset = off
     }
   } else if (match(state, 'keyword', 'OFFSET')) {
@@ -349,6 +357,9 @@ export function parseSelectInternal(state) {
     if (!Number.isFinite(off)) {
       throw parseError(state, 'valid OFFSET value')
     }
+    if (off < 0) {
+      throw parseError(state, 'non-negative OFFSET value')
+    }
     offset = off
   }
 

package/src/parse/state.js

@@ -2,6 +2,7 @@ import { syntaxError } from '../parseErrors.js'
 
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
+ * @import { ParseError } from '../parseErrors.js'
  */
 
 /**
@@ -93,7 +94,7 @@ export function expectIdentifier(state) {
  * Helper function to create consistent parser error messages.
  * @param {ParserState} state
  * @param {string} expected - Description of what was expected
- * @returns {import('../parseErrors.js').ParseError}
+ * @returns {ParseError}
  */
 export function parseError(state, expected) {
   const tok = current(state)

package/src/parse/types.d.ts

@@ -0,0 +1,30 @@
+import { UserDefinedFunction } from '../types.js'
+
+export interface ParserState {
+  tokens: Token[]
+  pos: number
+  lastPos?: number
+  functions?: Record<string, UserDefinedFunction>
+}
+
+// Tokenizer types
+export type TokenType =
+  | 'keyword'
+  | 'identifier'
+  | 'number'
+  | 'string'
+  | 'operator'
+  | 'comma'
+  | 'dot'
+  | 'paren'
+  | 'semicolon'
+  | 'eof'
+
+export interface Token {
+  type: TokenType
+  value: string
+  positionStart: number
+  positionEnd: number
+  numericValue?: number | bigint
+  originalValue?: string
+}