squirreling 0.4.6 → 0.4.8

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 '../errors.js'
+
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
  */
@@ -86,7 +88,7 @@ export function expectIdentifier(state) {
 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, position: tok.position, after })
 }

package/src/parse/tokenize.js

@@ -1,3 +1,9 @@
+import {
+  invalidLiteralError,
+  unexpectedCharError,
+  unterminatedError,
+} from '../errors.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,61 @@ 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,
+          position: startPos,
+          numericValue: BigInt(text.slice(0, -1)),
+        }
+      } catch {
+        throw invalidLiteralError({ type: 'bigint', value: text.slice(0, -1), position: startPos })
+      }
+    }
+    if (isAlpha(peek())) {
+      throw invalidLiteralError({ type: 'number', value: text + peek(), position: startPos })
+    }
+    const num = parseFloat(text)
+    if (isNaN(num)) {
+      throw invalidLiteralError({ type: 'number', value: text, position: startPos })
+    }
+    return {
+      type: 'number',
+      value: text,
+      position: startPos,
+      numericValue: num,
+    }
+  }
+
   while (i < length) {
     const ch = peek()
 
@@ -102,41 +170,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
     }
 
@@ -170,7 +222,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)
         }
         const c = nextChar()
         if (c === quote) {
@@ -198,7 +250,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)
         }
         const c = nextChar()
         if (c === quote) {
@@ -288,9 +340,9 @@ export function tokenize(sql) {
     }
 
     if (tokens.length === 0) {
-      throw new Error(`Expected SELECT but found "${ch}" at position ${pos}`)
+      throw unexpectedCharError(ch, pos, true)
     }
-    throw new Error(`Unexpected character "${ch}" at position ${pos}`)
+    throw unexpectedCharError(ch, pos)
   }
 
   tokens.push({

package/src/types.d.ts

@@ -27,7 +27,15 @@ export interface ExecuteSqlOptions {
   query: string
 }
 
-export type SqlPrimitive = string | number | bigint | boolean | null
+export type SqlPrimitive =
+  | string
+  | number
+  | bigint
+  | boolean
+  | Date
+  | null
+  | SqlPrimitive[]
+  | Record<string, any>
 
 export interface SelectStatement {
   distinct: boolean
@@ -54,7 +62,9 @@ export interface FromSubquery {
   alias: string
 }
 
-export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp
+export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
+
+export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
 
 export type ComparisonOp = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>='
 
@@ -127,6 +137,14 @@ export interface SubqueryNode {
   subquery: SelectStatement
 }
 
+export type IntervalUnit = 'DAY' | 'MONTH' | 'YEAR' | 'HOUR' | 'MINUTE' | 'SECOND'
+
+export interface IntervalNode {
+  type: 'interval'
+  value: number
+  unit: IntervalUnit
+}
+
 export type ExprNode =
   | LiteralNode
   | IdentifierNode
@@ -139,6 +157,7 @@ export type ExprNode =
   | ExistsNode
   | CaseNode
   | SubqueryNode
+  | IntervalNode
 
 export interface StarColumn {
   kind: 'star'
@@ -146,9 +165,23 @@ export interface StarColumn {
   alias?: string
 }
 
-export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX'
-
-export type StringFunc = 'UPPER' | 'LOWER' | 'CONCAT' | 'LENGTH' | 'SUBSTRING' | 'SUBSTR' | 'TRIM' | 'REPLACE'
+export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'JSON_ARRAYAGG'
+
+export type StringFunc =
+  | 'UPPER'
+  | 'LOWER'
+  | 'CONCAT'
+  | 'LENGTH'
+  | 'SUBSTRING'
+  | 'SUBSTR'
+  | 'TRIM'
+  | 'REPLACE'
+  | 'JSON_VALUE'
+  | 'JSON_QUERY'
+  | 'JSON_OBJECT'
+  | 'CURRENT_DATE'
+  | 'CURRENT_TIME'
+  | 'CURRENT_TIMESTAMP'
 
 export interface AggregateArgStar {
   kind: 'star'
@@ -214,6 +247,6 @@ export interface Token {
   type: TokenType
   value: string
   position: number
-  numericValue?: number
+  numericValue?: number | bigint
   originalValue?: string
 }

package/src/validation.js

@@ -1,11 +1,19 @@
 
 /**
- * @import {AggregateFunc, BinaryOp, ComparisonOp, StringFunc} from './types.js'
+ * @import {AggregateFunc, BinaryOp, ComparisonOp, IntervalUnit, StringFunc} from './types.js'
  * @param {string} name
  * @returns {name is AggregateFunc}
  */
 export function isAggregateFunc(name) {
-  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX'].includes(name)
+  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'JSON_ARRAYAGG'].includes(name)
+}
+
+/**
+ * @param {string} name
+ * @returns {name is IntervalUnit}
+ */
+export function isIntervalUnit(name) {
+  return ['DAY', 'MONTH', 'YEAR', 'HOUR', 'MINUTE', 'SECOND'].includes(name)
 }
 
 /**
@@ -13,7 +21,24 @@ export function isAggregateFunc(name) {
  * @returns {name is StringFunc}
  */
 export function isStringFunc(name) {
-  return ['UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM', 'REPLACE', 'RANDOM', 'RAND'].includes(name)
+  return [
+    'UPPER',
+    'LOWER',
+    'CONCAT',
+    'LENGTH',
+    'SUBSTRING',
+    'SUBSTR',
+    'TRIM',
+    'REPLACE',
+    'RANDOM',
+    'RAND',
+    'JSON_VALUE',
+    'JSON_QUERY',
+    'JSON_OBJECT',
+    'CURRENT_DATE',
+    'CURRENT_TIME',
+    'CURRENT_TIMESTAMP',
+  ].includes(name)
 }
 
 /**