squirreling 0.4.8 → 0.6.0

package/src/parse/comparison.js

@@ -1,7 +1,7 @@
-import { syntaxError } from '../errors.js'
+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'
@@ -26,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')
@@ -33,6 +35,8 @@ export function parseComparison(state) {
       type: 'unary',
       op: 'IS NULL',
       argument: left,
+      positionStart: left.positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -40,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)
@@ -51,7 +56,11 @@ export function parseComparison(state) {
           op: 'LIKE',
           left,
           right,
+          positionStart: left.positionStart,
+          positionEnd: right.positionEnd,
         },
+        positionStart: notPositionStart,
+        positionEnd: right.positionEnd,
       }
     }
   }
@@ -64,6 +73,8 @@ export function parseComparison(state) {
       op: 'LIKE',
       left,
       right,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
 
@@ -71,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)
@@ -80,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,
       }
     }
   }
@@ -95,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,
     }
   }
 
@@ -104,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
 
@@ -111,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 syntaxError({ expected: '(', received: `"${parenTok.value}"`, position: parenTok.position, 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',
@@ -124,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
@@ -136,6 +158,7 @@ export function parseComparison(state) {
           if (!match(state, 'comma')) break
         }
         expect(state, 'paren', ')')
+        const positionEnd = lastPosition(state)
         return {
           type: 'unary',
           op: 'NOT',
@@ -143,7 +166,11 @@ export function parseComparison(state) {
             type: 'in valuelist',
             expr: left,
             values,
+            positionStart: left.positionStart,
+            positionEnd,
           },
+          positionStart: notPositionStart,
+          positionEnd,
         }
       }
     }
@@ -156,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 syntaxError({ expected: '(', received: `"${parenTok.value}"`, position: parenTok.position, 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') {
@@ -166,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
@@ -181,6 +210,8 @@ export function parseComparison(state) {
         type: 'in valuelist',
         expr: left,
         values,
+        positionStart: left.positionStart,
+        positionEnd: lastPosition(state),
       }
     }
   }
@@ -193,6 +224,8 @@ export function parseComparison(state) {
       op: tok.value,
       left,
       right,
+      positionStart: left.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
 

package/src/parse/expression.js

@@ -3,11 +3,11 @@ import {
   missingClauseError,
   syntaxError,
   unknownFunctionError,
-} from '../errors.js'
-import { isAggregateFunc, isIntervalUnit, isStringFunc } from '../validation.js'
+} 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, IntervalNode, ParserState, SelectStatement, WhenClause } from '../types.js'
@@ -18,6 +18,7 @@ import { consume, current, expect, expectIdentifier, match, peekToken } from './
  * @returns {IntervalNode}
  */
 function parseInterval(state) {
+  const { positionStart } = current(state)
   consume(state) // INTERVAL
 
   // Handle optional negative sign
@@ -39,11 +40,11 @@ function parseInterval(state) {
     consume(state)
     const parsed = parseFloat(valueTok.value)
     if (isNaN(parsed)) {
-      throw invalidLiteralError({ type: 'interval value', value: valueTok.value, position: valueTok.position })
+      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}"`, position: valueTok.position })
+    throw syntaxError({ expected: 'interval value (number)', received: `"${valueTok.value}"`, positionStart: valueTok.positionStart, positionEnd: valueTok.positionEnd })
   }
 
   // Get unit keyword
@@ -52,13 +53,14 @@ function parseInterval(state) {
     throw invalidLiteralError({
       type: 'interval unit',
       value: unitTok.value,
-      position: unitTok.position,
+      positionStart: unitTok.positionStart,
+      positionEnd: unitTok.positionEnd,
       validValues: 'DAY, MONTH, YEAR, HOUR, MINUTE, SECOND',
     })
   }
   consume(state)
 
-  return { type: 'interval', value, unit: unitTok.value }
+  return { type: 'interval', value, unit: unitTok.value, positionStart, positionEnd: lastPosition(state) }
 }
 
 /**
@@ -75,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
@@ -85,6 +88,8 @@ export function parsePrimary(state) {
       return {
         type: 'subquery',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     // Regular grouped expression
@@ -109,6 +114,8 @@ export function parsePrimary(state) {
         type: 'cast',
         expr,
         toType: typeTok.value,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
 
@@ -117,8 +124,8 @@ export function parsePrimary(state) {
       const funcName = tok.value
 
       // validate function names
-      if (!isStringFunc(funcName) && !isAggregateFunc(funcName)) {
-        throw unknownFunctionError(funcName, tok.position)
+      if (!isStringFunc(funcName) && !isAggregateFunc(funcName) && !isMathFunc(funcName)) {
+        throw unknownFunctionError({ funcName, positionStart: tok.positionStart, positionEnd: tok.positionEnd })
       }
 
       consume(state) // function name
@@ -131,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)
@@ -150,6 +160,8 @@ export function parsePrimary(state) {
         type: 'function',
         name: funcName,
         args,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
 
@@ -161,6 +173,8 @@ export function parsePrimary(state) {
         type: 'function',
         name: tok.value,
         args: [],
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
 
@@ -177,6 +191,8 @@ export function parsePrimary(state) {
     return {
       type: 'identifier',
       name,
+      positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -185,6 +201,8 @@ export function parsePrimary(state) {
     return {
       type: 'literal',
       value: tok.numericValue ?? null,
+      positionStart,
+      positionEnd: lastPosition(state),
     }
   }
 
@@ -193,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
@@ -215,6 +235,8 @@ export function parsePrimary(state) {
       return {
         type: 'exists',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     if (tok.value === 'CASE') {
@@ -260,6 +282,8 @@ export function parsePrimary(state) {
         caseExpr,
         whenClauses,
         elseResult,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     if (tok.value === 'INTERVAL') {
@@ -274,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 syntaxError({ expected: 'expression', received: found, position: tok.position })
+  throw syntaxError({ expected: 'expression', received: found, positionStart: tok.positionStart, positionEnd: tok.positionEnd })
 }
 
 /**
@@ -294,6 +320,8 @@ function parseOr(state) {
       op: 'OR',
       left: node,
       right,
+      positionStart: node.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
   return node
@@ -312,6 +340,8 @@ function parseAnd(state) {
       op: 'AND',
       left: node,
       right,
+      positionStart: node.positionStart,
+      positionEnd: right.positionEnd,
     }
   }
   return node
@@ -322,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') {
@@ -331,6 +363,8 @@ function parseNot(state) {
       return {
         type: 'not exists',
         subquery,
+        positionStart,
+        positionEnd: lastPosition(state),
       }
     }
     const argument = parseNot(state)
@@ -338,6 +372,8 @@ function parseNot(state) {
       type: 'unary',
       op: 'NOT',
       argument,
+      positionStart,
+      positionEnd: argument.positionEnd,
     }
   }
   return parseComparison(state)
@@ -359,6 +395,8 @@ export function parseAdditive(state) {
         op: tok.value,
         left: node,
         right,
+        positionStart: node.positionStart,
+        positionEnd: right.positionEnd,
       }
     } else {
       break
@@ -383,6 +421,8 @@ function parseMultiplicative(state) {
         op: tok.value,
         left: node,
         right,
+        positionStart: node.positionStart,
+        positionEnd: right.positionEnd,
       }
     } else {
       break

package/src/parse/state.js

@@ -1,4 +1,4 @@
-import { syntaxError } from '../errors.js'
+import { syntaxError } from '../parseErrors.js'
 
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
@@ -31,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
@@ -83,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 ? prevToken.originalValue ?? prevToken.value : undefined
   const received = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
-  return syntaxError({ expected, received, position: tok.position, after })
+  return syntaxError({ expected, received, positionStart: tok.positionStart, positionEnd: tok.positionEnd, after })
 }

package/src/parse/tokenize.js

@@ -2,7 +2,7 @@ import {
   invalidLiteralError,
   unexpectedCharError,
   unterminatedError,
-} from '../errors.js'
+} from '../parseErrors.js'
 
 /**
  * @import { Token } from '../types.d.ts'
@@ -117,24 +117,26 @@ export function tokenize(sql) {
         return {
           type: 'number',
           value: text,
-          position: startPos,
+          positionStart: startPos,
+          positionEnd: i,
           numericValue: BigInt(text.slice(0, -1)),
         }
       } catch {
-        throw invalidLiteralError({ type: 'bigint', value: text.slice(0, -1), position: startPos })
+        throw invalidLiteralError({ type: 'bigint', value: text.slice(0, -1), positionStart: startPos, positionEnd: i })
       }
     }
     if (isAlpha(peek())) {
-      throw invalidLiteralError({ type: 'number', value: text + peek(), position: startPos })
+      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, position: startPos })
+      throw invalidLiteralError({ type: 'number', value: text, positionStart: startPos, positionEnd: i })
     }
     return {
       type: 'number',
       value: text,
-      position: startPos,
+      positionStart: startPos,
+      positionEnd: i,
       numericValue: num,
     }
   }
@@ -204,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
@@ -222,7 +226,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw unterminatedError('string', pos)
+          throw unterminatedError('string', pos, length)
         }
         const c = nextChar()
         if (c === quote) {
@@ -239,7 +243,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'string',
         value: text,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -250,7 +255,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw unterminatedError('identifier', pos)
+          throw unterminatedError('identifier', pos, length)
         }
         const c = nextChar()
         if (c === quote) {
@@ -267,7 +272,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'identifier',
         value: text,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -283,7 +289,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'operator',
         value: op,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -294,7 +301,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'operator',
         value: ch,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -304,7 +312,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'comma',
         value: ',',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -314,7 +323,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'dot',
         value: '.',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -324,7 +334,8 @@ export function tokenize(sql) {
       tokens.push({
         type: 'paren',
         value: ch,
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
@@ -334,21 +345,23 @@ export function tokenize(sql) {
       tokens.push({
         type: 'semicolon',
         value: ';',
-        position: pos,
+        positionStart: pos,
+        positionEnd: i,
       })
       continue
     }
 
     if (tokens.length === 0) {
-      throw unexpectedCharError(ch, pos, true)
+      throw unexpectedCharError({ char: ch, positionStart: pos, expectsSelect: true })
     }
-    throw unexpectedCharError(ch, pos)
+    throw unexpectedCharError({ char: ch, positionStart: pos })
   }
 
   tokens.push({
     type: 'eof',
     value: '',
-    position: length,
+    positionStart: length,
+    positionEnd: length,
   })
 
   return tokens