squirreling 0.4.7 → 0.5.0

package/src/parse/expression.js

@@ -1,12 +1,68 @@
-import { isAggregateFunc, isStringFunc } from '../validation.js'
+import {
+  invalidLiteralError,
+  missingClauseError,
+  syntaxError,
+  unknownFunctionError,
+} from '../parseErrors.js'
+import { isAggregateFunc, isIntervalUnit, isMathFunc, isStringFunc } from '../validation.js'
 import { parseComparison } from './comparison.js'
 import { parseSelectInternal } from './parse.js'
-import { consume, current, expect, expectIdentifier, match, peekToken } from './state.js'
+import { consume, current, expect, expectIdentifier, lastPosition, match, peekToken } from './state.js'
 
 /**
- * @import { ExprNode, ParserState, SelectStatement, WhenClause } from '../types.js'
+ * @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}
@@ -21,6 +77,7 @@ export function parseExpression(state) {
  */
 export function parsePrimary(state) {
   const tok = current(state)
+  const { positionStart } = tok
 
   if (tok.type === 'paren' && tok.value === '(') {
     // Peek ahead to see if this is a scalar subquery
@@ -31,6 +88,8 @@ export function parsePrimary(state) {
       return {
         type: 'subquery',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     // Regular grouped expression
@@ -55,6 +114,8 @@ export function parsePrimary(state) {
         type: 'cast',
         expr,
         toType: typeTok.value,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
 
@@ -63,8 +124,8 @@ export function parsePrimary(state) {
       const funcName = tok.value
 
       // validate function names
-      if (!isStringFunc(funcName) && !isAggregateFunc(funcName)) {
-        throw new Error(`Unknown function "${funcName}" at position ${tok.position}`)
+      if (!isStringFunc(funcName) && !isAggregateFunc(funcName) && !isMathFunc(funcName)) {
+        throw unknownFunctionError({ funcName, positionStart: tok.positionStart, positionEnd: tok.positionEnd })
       }
 
       consume(state) // function name
@@ -77,10 +138,13 @@ export function parsePrimary(state) {
         while (true) {
           // Handle COUNT(*) - treat * as a special identifier
           if (current(state).type === 'operator' && current(state).value === '*') {
+            const starTok = current(state)
             consume(state)
             args.push({
               type: 'identifier',
               name: '*',
+              positionStart: starTok.positionStart,
+              positionEnd: lastPosition(state),
             })
           } else {
             const arg = parseExpression(state)
@@ -96,6 +160,21 @@ export function parsePrimary(state) {
         type: 'function',
         name: funcName,
         args,
+        positionStart,
+        positionEnd: lastPosition(state),
+      }
+    }
+
+    // Niladic datetime functions (no parentheses required per ANSI SQL)
+    const niladicFuncs = ['CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP']
+    if (niladicFuncs.includes(tok.value)) {
+      consume(state)
+      return {
+        type: 'function',
+        name: tok.value,
+        args: [],
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
 
@@ -112,6 +191,8 @@ export function parsePrimary(state) {
     return {
       type: 'identifier',
       name,
+      positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -120,6 +201,8 @@ export function parsePrimary(state) {
     return {
       type: 'literal',
       value: tok.numericValue ?? null,
+      positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -128,21 +211,23 @@ export function parsePrimary(state) {
     return {
       type: 'literal',
       value: tok.value,
+      positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
   if (tok.type === 'keyword') {
     if (tok.value === 'TRUE') {
       consume(state)
-      return { type: 'literal', value: true }
+      return { type: 'literal', value: true, positionStart, positionEnd: lastPosition(state) }
     }
     if (tok.value === 'FALSE') {
       consume(state)
-      return { type: 'literal', value: false }
+      return { type: 'literal', value: false, positionStart, positionEnd: lastPosition(state) }
     }
     if (tok.value === 'NULL') {
       consume(state)
-      return { type: 'literal', value: null }
+      return { type: 'literal', value: null, positionStart, positionEnd: lastPosition(state) }
     }
     if (tok.value === 'EXISTS') {
       consume(state) // EXISTS
@@ -150,6 +235,8 @@ export function parsePrimary(state) {
       return {
         type: 'exists',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     if (tok.value === 'CASE') {
@@ -175,7 +262,10 @@ export function parsePrimary(state) {
       }
 
       if (whenClauses.length === 0) {
-        throw new Error('CASE expression must have at least one WHEN clause')
+        throw missingClauseError({
+          missing: 'at least one WHEN clause',
+          context: 'CASE expression',
+        })
       }
 
       // Parse optional ELSE clause
@@ -192,8 +282,13 @@ export function parsePrimary(state) {
         caseExpr,
         whenClauses,
         elseResult,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
+    if (tok.value === 'INTERVAL') {
+      return parseInterval(state)
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {
@@ -203,11 +298,13 @@ export function parsePrimary(state) {
       type: 'unary',
       op: '-',
       argument,
+      positionStart,
+      positionEnd: argument.positionEnd,
     }
   }
 
   const found = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
-  throw new Error(`Expected expression but found ${found} at position ${tok.position}`)
+  throw syntaxError({ expected: 'expression', received: found, positionStart: tok.positionStart, positionEnd: tok.positionEnd })
 }
 
 /**
@@ -223,6 +320,8 @@ function parseOr(state) {
       op: 'OR',
       left: node,
       right,
+      positionStart: node.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
   return node
@@ -241,6 +340,8 @@ function parseAnd(state) {
       op: 'AND',
       left: node,
       right,
+      positionStart: node.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
   return node
@@ -251,7 +352,9 @@ function parseAnd(state) {
  * @returns {ExprNode}
  */
 function parseNot(state) {
+  const tok = current(state)
   if (match(state, 'keyword', 'NOT')) {
+    const { positionStart } = tok
     // Check for NOT EXISTS
     const nextTok = current(state)
     if (nextTok.type === 'keyword' && nextTok.value === 'EXISTS') {
@@ -260,6 +363,8 @@ function parseNot(state) {
       return {
         type: 'not exists',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     const argument = parseNot(state)
@@ -267,6 +372,8 @@ function parseNot(state) {
       type: 'unary',
       op: 'NOT',
       argument,
+      positionStart,
+      positionEnd: argument.positionEnd,
     }
   }
   return parseComparison(state)
@@ -288,6 +395,8 @@ export function parseAdditive(state) {
         op: tok.value,
         left: node,
         right,
+        positionStart: node.positionStart,
+        positionEnd: right.positionEnd,
       }
     } else {
       break
@@ -312,6 +421,8 @@ function parseMultiplicative(state) {
         op: tok.value,
         left: node,
         right,
+        positionStart: node.positionStart,
+        positionEnd: right.positionEnd,
       }
     } else {
       break

package/src/parse/parse.js

@@ -63,6 +63,11 @@ function parseSelectList(state) {
   return cols
 }
 
+// Keywords that can start a valid expression in SELECT
+const EXPRESSION_START_KEYWORDS = new Set([
+  'CASE', 'TRUE', 'FALSE', 'NULL', 'EXISTS', 'NOT', 'INTERVAL',
+])
+
 /**
  * @param {ParserState} state
  * @returns {SelectColumn}
@@ -70,7 +75,7 @@ function parseSelectList(state) {
 function parseSelectItem(state) {
   const tok = current(state)
 
-  if (tok.type === 'keyword' && tok.value !== 'CASE' || tok.type === 'eof') {
+  if (tok.type === 'keyword' && !EXPRESSION_START_KEYWORDS.has(tok.value) || tok.type === 'eof') {
     throw parseError(state, 'column name or expression')
   }
 

package/src/parse/state.js

@@ -1,3 +1,5 @@
+import { syntaxError } from '../parseErrors.js'
+
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
  */
@@ -29,12 +31,22 @@ export function peekToken(state, offset) {
  */
 export function consume(state) {
   const tok = current(state)
+  state.lastPos = tok.positionEnd
   if (state.pos < state.tokens.length - 1) {
     state.pos += 1
   }
   return tok
 }
 
+/**
+ * Gets the position after the last consumed token.
+ * @param {ParserState} state
+ * @returns {number}
+ */
+export function lastPosition(state) {
+  return state.lastPos ?? 0
+}
+
 /**
  * @param {ParserState} state
  * @param {TokenType} type
@@ -81,12 +93,12 @@ export function expectIdentifier(state) {
  * Helper function to create consistent parser error messages.
  * @param {ParserState} state
  * @param {string} expected - Description of what was expected
- * @returns {Error}
+ * @returns {import('../parseErrors.js').ParseError}
  */
 export function parseError(state, expected) {
   const tok = current(state)
   const prevToken = state.tokens[state.pos - 1]
-  const after = prevToken ? ` after "${prevToken.originalValue ?? prevToken.value}"` : ''
-  const found = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
-  return new Error(`Expected ${expected}${after} but found ${found} at position ${tok.position}`)
+  const after = prevToken ? prevToken.originalValue ?? prevToken.value : undefined
+  const received = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
+  return syntaxError({ expected, received, positionStart: tok.positionStart, positionEnd: tok.positionEnd, after })
 }

package/src/parse/tokenize.js

@@ -1,3 +1,9 @@
+import {
+  invalidLiteralError,
+  unexpectedCharError,
+  unterminatedError,
+} from '../parseErrors.js'
+
 /**
  * @import { Token } from '../types.d.ts'
  */
@@ -41,6 +47,13 @@ const KEYWORDS = new Set([
   'FULL',
   'OUTER',
   'ON',
+  'INTERVAL',
+  'DAY',
+  'MONTH',
+  'YEAR',
+  'HOUR',
+  'MINUTE',
+  'SECOND',
 ])
 
 /**
@@ -71,6 +84,63 @@ export function tokenize(sql) {
     return ch
   }
 
+  /**
+   * @param {number} startPos
+   * @param {string} prefix
+   * @returns {Token}
+   */
+  function parseNumber(startPos, prefix = '') {
+    let text = prefix
+    while (isDigit(peek())) {
+      text += nextChar()
+    }
+    if (peek() === '.') {
+      text += nextChar()
+      while (isDigit(peek())) {
+        text += nextChar()
+      }
+    }
+    // exponent
+    if (peek() === 'e' || peek() === 'E') {
+      text += nextChar()
+      if (peek() === '+' || peek() === '-') {
+        text += nextChar()
+      }
+      while (isDigit(peek())) {
+        text += nextChar()
+      }
+    }
+    // bigint suffix
+    if (peek() === 'n') {
+      text += nextChar()
+      try {
+        return {
+          type: 'number',
+          value: text,
+          positionStart: startPos,
+          positionEnd: i,
+          numericValue: BigInt(text.slice(0, -1)),
+        }
+      } catch {
+        throw invalidLiteralError({ type: 'bigint', value: text.slice(0, -1), positionStart: startPos, positionEnd: i })
+      }
+    }
+    if (isAlpha(peek())) {
+      throw invalidLiteralError({ type: 'number', value: text + peek(), positionStart: startPos, positionEnd: i + 1 })
+    }
+    const num = parseFloat(text)
+    if (isNaN(num)) {
+      throw invalidLiteralError({ type: 'number', value: text, positionStart: startPos, positionEnd: i })
+    }
+    return {
+      type: 'number',
+      value: text,
+      positionStart: startPos,
+      positionEnd: i,
+      numericValue: num,
+    }
+  }
+
   while (i < length) {
     const ch = peek()
 
@@ -102,41 +172,25 @@ export function tokenize(sql) {
 
     const pos = i
 
+    // negative numbers (when not subtraction)
+    if (ch === '-' && i + 1 < length && isDigit(sql[i + 1])) {
+      const lastToken = tokens[tokens.length - 1]
+      const isValueBefore = lastToken && (
+        lastToken.type === 'identifier' ||
+        lastToken.type === 'number' ||
+        lastToken.type === 'string' ||
+        lastToken.type === 'paren' && lastToken.value === ')'
+      )
+      if (!isValueBefore) {
+        nextChar() // consume '-'
+        tokens.push(parseNumber(pos, '-'))
+        continue
+      }
+    }
+
     // numbers
     if (isDigit(ch)) {
-      let text = ''
-      while (isDigit(peek())) {
-        text += nextChar()
-      }
-      if (peek() === '.') {
-        text += nextChar()
-        while (isDigit(peek())) {
-          text += nextChar()
-        }
-      }
-      // exponent
-      if (peek() === 'e' || peek() === 'E') {
-        text += nextChar()
-        if (peek() === '+' || peek() === '-') {
-          text += nextChar()
-        }
-        while (isDigit(peek())) {
-          text += nextChar()
-        }
-      }
-      if (isAlpha(peek())) {
-        throw new Error(`Invalid number at position ${pos}: ${text}${peek()}`)
-      }
-      const num = parseFloat(text)
-      if (isNaN(num)) {
-        throw new Error(`Invalid number at position ${pos}: ${text}`)
-      }
-      tokens.push({
-        type: 'number',
-        value: text,
-        position: pos,
-        numericValue: num,
-      })
+      tokens.push(parseNumber(pos))
       continue
     }
 
@@ -152,13 +206,15 @@ export function tokenize(sql) {
           type: 'keyword',
           value: upper,
           originalValue: text,
-          position: pos,
+          positionStart: pos,
+          positionEnd: i,
         })
       } else {
         tokens.push({
           type: 'identifier',
           value: text,
-          position: pos,
+          positionStart: pos,
+          positionEnd: i,
         })
       }
       continue
@@ -170,7 +226,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw new Error(`Unterminated string literal starting at position ${pos}`)
+          throw unterminatedError('string', pos, length)
         }
         const c = nextChar()
         if (c === quote) {
@@ -187,7 +243,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'string',
         value: text,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -198,7 +255,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw new Error(`Unterminated identifier starting at position ${pos}`)
+          throw unterminatedError('identifier', pos, length)
         }
         const c = nextChar()
         if (c === quote) {
@@ -215,7 +272,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'identifier',
         value: text,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -231,7 +289,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'operator',
         value: op,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -242,7 +301,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'operator',
         value: ch,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -252,7 +312,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'comma',
         value: ',',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -262,7 +323,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'dot',
         value: '.',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -272,7 +334,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'paren',
         value: ch,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -282,21 +345,23 @@ export function tokenize(sql) {
       tokens.push({
         type: 'semicolon',
         value: ';',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
 
     if (tokens.length === 0) {
-      throw new Error(`Expected SELECT but found "${ch}" at position ${pos}`)
+      throw unexpectedCharError({ char: ch, positionStart: pos, expectsSelect: true })
     }
-    throw new Error(`Unexpected character "${ch}" at position ${pos}`)
+    throw unexpectedCharError({ char: ch, positionStart: pos })
   }
 
   tokens.push({
     type: 'eof',
     value: '',
-    position: length,
+    positionStart: length,
+    positionEnd: length,
   })
 
   return tokens