squirreling 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Squirreling SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/execute/execute.js

@@ -142,6 +142,11 @@ function evaluateSelectAst(select, dataSource) {
     throw new Error('JOIN is not supported')
   }
 
+  // Check for unsupported subquery in FROM clause
+  if (typeof select.from !== 'string') {
+    throw new Error('Subquery in FROM clause is not supported')
+  }
+
   // SQL priority: from, where, group by, having, select, order by, offset, limit
 
   // WHERE clause filtering

package/src/execute/expression.js

@@ -190,5 +190,39 @@ export function evaluateExpr(node, row) {
     throw new Error('Unsupported CAST to type ' + node.toType)
   }
 
+  // IN and NOT IN with value lists
+  if (node.type === 'in valuelist') {
+    const exprVal = evaluateExpr(node.expr, row)
+    for (const valueNode of node.values) {
+      const val = evaluateExpr(valueNode, row)
+      if (exprVal === val) return true
+    }
+    return false
+  }
+  if (node.type === 'not in valuelist') {
+    const exprVal = evaluateExpr(node.expr, row)
+    for (const valueNode of node.values) {
+      const val = evaluateExpr(valueNode, row)
+      if (exprVal === val) return false
+    }
+    return true
+  }
+
+  // IN and NOT IN with subqueries
+  if (node.type === 'in') {
+    throw new Error('WHERE IN with subqueries is not yet supported.')
+  }
+  if (node.type === 'not in') {
+    throw new Error('WHERE NOT IN with subqueries is not yet supported.')
+  }
+
+  // EXISTS and NOT EXISTS with subqueries
+  if (node.type === 'exists') {
+    throw new Error('WHERE EXISTS with subqueries is not yet supported.')
+  }
+  if (node.type === 'not exists') {
+    throw new Error('WHERE NOT EXISTS with subqueries is not yet supported.')
+  }
+
   throw new Error('Unknown expression node type ' + node.type)
 }

package/src/parse/expression.js

@@ -1,5 +1,5 @@
 /**
- * @import { ExprCursor, ExprNode, BinaryOp } from '../types.js'
+ * @import { ExprCursor, ExprNode, BinaryOp, SelectStatement } from '../types.js'
  */
 
 /**
@@ -30,6 +30,21 @@ export function parsePrimary(c) {
   if (tok.type === 'identifier') {
     const next = c.peek(1)
 
+    // CAST expression
+    if (tok.value === 'CAST' && next.type === 'paren' && next.value === '(') {
+      c.consume() // CAST
+      c.consume() // '('
+      const expr = parseExpression(c)
+      c.expect('keyword', 'AS')
+      const typeTok = c.expectIdentifier()
+      c.expect('paren', ')')
+      return {
+        type: 'cast',
+        expr,
+        toType: typeTok.value,
+      }
+    }
+
     // function call
     if (next.type === 'paren' && next.value === '(') {
       const funcName = tok.value
@@ -111,6 +126,17 @@ export function parsePrimary(c) {
       c.consume()
       return { type: 'literal', value: null }
     }
+    if (tok.value === 'EXISTS') {
+      c.consume() // EXISTS
+      if (!c.parseSubquery) {
+        throw new Error('Subquery parsing not available in this context')
+      }
+      const subquery = c.parseSubquery()
+      return {
+        type: 'exists',
+        subquery,
+      }
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {
@@ -123,14 +149,8 @@ export function parsePrimary(c) {
     }
   }
 
-  throw new Error(
-    'Unexpected token in expression at position ' +
-      tok.position +
-      ': ' +
-      tok.type +
-      ' ' +
-      tok.value
-  )
+  const found = tok.type === 'eof' ? 'end of query' : `"${tok.originalValue ?? tok.value}"`
+  throw new Error(`Expected expression but found ${found} at position ${tok.position}`)
 }
 
 /**
@@ -175,6 +195,19 @@ function parseAnd(c) {
  */
 function parseNot(c) {
   if (c.match('keyword', 'NOT')) {
+    // Check for NOT EXISTS
+    const nextTok = c.current()
+    if (nextTok.type === 'keyword' && nextTok.value === 'EXISTS') {
+      c.consume() // EXISTS
+      if (!c.parseSubquery) {
+        throw new Error('Subquery parsing not available in this context')
+      }
+      const subquery = c.parseSubquery()
+      return {
+        type: 'not exists',
+        subquery,
+      }
+    }
     const argument = parseNot(c)
     return {
       type: 'unary',
@@ -257,6 +290,89 @@ function parseComparison(c) {
     }
   }
 
+  // [NOT] IN
+  if (tok.type === 'keyword' && tok.value === 'NOT') {
+    const nextTok = c.peek(1)
+    if (nextTok.type === 'keyword' && nextTok.value === 'IN') {
+      c.consume() // NOT
+      c.consume() // IN
+
+      // Check if it's a subquery or a list of values by peeking ahead
+      // parseSubquery expects to consume the opening paren itself
+      const parenTok = c.current()
+      if (parenTok.type !== 'paren' || parenTok.value !== '(') {
+        throw new Error('Expected ( after IN')
+      }
+      const peekTok = c.peek(1)
+      if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
+        // Subquery - let parseSubquery handle the parens
+        if (!c.parseSubquery) {
+          throw new Error('Subquery parsing not available in this context')
+        }
+        const subquery = c.parseSubquery()
+        return {
+          type: 'not in',
+          expr: left,
+          subquery,
+        }
+      } else {
+        // Parse list of values - we handle the parens
+        c.consume() // '('
+        /** @type {ExprNode[]} */
+        const values = []
+        while (true) {
+          values.push(parseExpression(c))
+          if (!c.match('comma')) break
+        }
+        c.expect('paren', ')')
+        return {
+          type: 'not in valuelist',
+          expr: left,
+          values,
+        }
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'IN') {
+    c.consume() // IN
+
+    // Check if it's a subquery or a list of values by peeking ahead
+    // parseSubquery expects to consume the opening paren itself
+    const parenTok = c.current()
+    if (parenTok.type !== 'paren' || parenTok.value !== '(') {
+      throw new Error('Expected ( after IN')
+    }
+    const peekTok = c.peek(1)
+    if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
+      // Subquery - let parseSubquery handle the parens
+      if (!c.parseSubquery) {
+        throw new Error('Subquery parsing not available in this context')
+      }
+      const subquery = c.parseSubquery()
+      return {
+        type: 'in',
+        expr: left,
+        subquery,
+      }
+    } else {
+      // Parse list of values - we handle the parens
+      c.consume() // '('
+      /** @type {ExprNode[]} */
+      const values = []
+      while (true) {
+        values.push(parseExpression(c))
+        if (!c.match('comma')) break
+      }
+      c.expect('paren', ')')
+      return {
+        type: 'in valuelist',
+        expr: left,
+        values,
+      }
+    }
+  }
+
   if (tok.type === 'operator' && isComparisonOperator(tok.value)) {
     c.consume()
     const right = parsePrimary(c)

package/src/parse/parse.js

@@ -1,5 +1,5 @@
 /**
- * @import { AggregateColumn, AggregateArg, AggregateFunc, ExprCursor, ExprNode, JoinClause, JoinType, OrderByItem, ParserState, SelectStatement, SelectColumn, StringFunc, Token, TokenType } from '../types.js'
+ * @import { AggregateColumn, AggregateArg, AggregateFunc, ExprCursor, ExprNode, FromSubquery, JoinClause, JoinType, OrderByItem, ParserState, SelectStatement, SelectColumn, StringFunc, Token, TokenType } from '../types.js'
  */
 
 import { tokenize } from './tokenize.js'
@@ -18,11 +18,11 @@ const RESERVED_AFTER_COLUMN = new Set([
 ])
 
 /**
- * @param {string} sql
+ * @param {string} query
  * @returns {SelectStatement}
  */
-export function parseSql(sql) {
-  const tokens = tokenize(sql)
+export function parseSql(query) {
+  const tokens = tokenize(query)
   /** @type {ParserState} */
   const state = { tokens, pos: 0 }
   const select = parseSelectInternal(state)
@@ -123,6 +123,12 @@ function createExprCursor(state) {
     match: (type, value) => match(state, type, value),
     expect: (type, value) => expect(state, type, value),
     expectIdentifier: () => expectIdentifier(state),
+    parseSubquery: () => {
+      expect(state, 'paren', '(')
+      const query = parseSelectInternal(state)
+      expect(state, 'paren', ')')
+      return query
+    },
   }
 }
 
@@ -384,6 +390,24 @@ function parseJoins(state) {
   return joins
 }
 
+/**
+ * Parses a subquery in parentheses with an alias
+ * @param {ParserState} state
+ * @returns {FromSubquery}
+ */
+function parseSubquery(state) {
+  expect(state, 'paren', '(')
+  const query = parseSelectInternal(state)
+  expect(state, 'paren', ')')
+  expect(state, 'keyword', 'AS')
+  const aliasTok = expectIdentifier(state)
+  return {
+    kind: 'subquery',
+    query,
+    alias: aliasTok.value,
+  }
+}
+
 /**
  * @param {ParserState} state
  * @returns {SelectStatement}
@@ -399,7 +423,17 @@ function parseSelectInternal(state) {
   const columns = parseSelectList(state)
 
   expect(state, 'keyword', 'FROM')
-  const from = expectIdentifier(state).value // table name
+
+  // Check if it's a subquery or table name
+  let from
+  const tok = current(state)
+  if (tok.type === 'paren' && tok.value === '(') {
+    // Subquery: SELECT * FROM (SELECT ...) AS alias
+    from = parseSubquery(state)
+  } else {
+    // Simple table name: SELECT * FROM users
+    from = expectIdentifier(state).value
+  }
 
   // Parse JOIN clauses
   const joins = parseJoins(state)
@@ -521,5 +555,6 @@ function parseError(state, expected) {
   const tok = current(state)
   const prevToken = state.tokens[state.pos - 1]
   const after = prevToken ? ` after "${prevToken.originalValue ?? prevToken.value}"` : ''
-  return new Error(`Expected ${expected}${after} at position ${tok.position}`)
+  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}`)
 }

package/src/parse/tokenize.js

@@ -25,6 +25,7 @@ const KEYWORDS = new Set([
   'NULL',
   'LIKE',
   'IN',
+  'EXISTS',
   'BETWEEN',
   'CASE',
   'WHEN',
@@ -122,11 +123,11 @@ export function tokenize(sql) {
         }
       }
       if (isAlpha(peek())) {
-        throw new Error('Invalid number at position ' + pos + ': ' + text + 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)
+        throw new Error(`Invalid number at position ${pos}: ${text}`)
       }
       tokens.push({
         type: 'number',
@@ -167,7 +168,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw new Error('Unterminated string literal starting at position ' + pos)
+          throw new Error(`Unterminated string literal starting at position ${pos}`)
         }
         const c = nextChar()
         if (c === quote) {
@@ -195,7 +196,7 @@ export function tokenize(sql) {
       let text = ''
       while (i <= length) {
         if (i === length) {
-          throw new Error('Unterminated identifier starting at position ' + pos)
+          throw new Error(`Unterminated identifier starting at position ${pos}`)
         }
         const c = nextChar()
         if (c === quote) {
@@ -285,9 +286,9 @@ export function tokenize(sql) {
     }
 
     if (tokens.length === 0) {
-      throw new Error('Expected SELECT at position ' + pos)
+      throw new Error(`Expected SELECT but found "${ch}" at position ${pos}`)
     }
-    throw new Error('Unexpected character at position ' + pos + ': ' + ch)
+    throw new Error(`Unexpected character "${ch}" at position ${pos}`)
   }
 
   tokens.push({

package/src/types.d.ts

@@ -15,10 +15,16 @@ export interface ExecuteSqlOptions {
 
 export type SqlPrimitive = string | number | bigint | boolean | null
 
+export interface FromSubquery {
+  kind: 'subquery'
+  query: SelectStatement
+  alias: string
+}
+
 export interface SelectStatement {
   distinct: boolean
   columns: SelectColumn[]
-  from?: string
+  from?: string | FromSubquery
   joins: JoinClause[]
   where?: ExprNode
   groupBy: ExprNode[]
@@ -102,6 +108,23 @@ export interface BetweenNode {
   upper: ExprNode
 }
 
+export interface InSubqueryNode {
+  type: 'in' | 'not in'
+  expr: ExprNode
+  subquery: SelectStatement
+}
+
+export interface InValuesNode {
+  type: 'in valuelist' | 'not in valuelist'
+  expr: ExprNode
+  values: ExprNode[]
+}
+
+export interface ExistsNode {
+  type: 'exists' | 'not exists'
+  subquery: SelectStatement
+}
+
 export type ExprNode =
   | LiteralNode
   | IdentifierNode
@@ -110,6 +133,9 @@ export type ExprNode =
   | FunctionNode
   | CastNode
   | BetweenNode
+  | InSubqueryNode
+  | InValuesNode
+  | ExistsNode
 
 export interface StarColumn {
   kind: 'star'
@@ -184,4 +210,5 @@ export interface ExprCursor {
   match(type: TokenType, value?: string): boolean
   expect(type: TokenType, value: string): Token
   expectIdentifier(): Token
+  parseSubquery?: () => SelectStatement
 }