squirreling 0.2.1 → 0.2.3

package/README.md

@@ -30,7 +30,7 @@ const source = [
   { id: 2, name: 'Bob' },
 ]
 
-const result = executeSql({ source, sql: 'SELECT UPPER(name) AS name_upper FROM users' })
+const result = executeSql({ source, query: 'SELECT UPPER(name) AS name_upper FROM users' })
 console.log(result)
 // Output: [ { name_upper: 'ALICE' }, { name_upper: 'BOB' } ]
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Squirreling SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -40,7 +40,7 @@
     "@types/node": "24.10.1",
     "@vitest/coverage-v8": "4.0.13",
     "eslint": "9.39.1",
-    "eslint-plugin-jsdoc": "61.4.0",
+    "eslint-plugin-jsdoc": "61.4.1",
     "typescript": "5.9.3",
     "vitest": "4.0.13"
   }

package/src/execute/execute.js

@@ -4,7 +4,7 @@
 
 import { defaultAggregateAlias, evaluateAggregate } from './aggregates.js'
 import { evaluateExpr } from './expression.js'
-import { createHavingContext, evaluateHavingExpr } from './having.js'
+import { evaluateHavingExpr } from './having.js'
 import { parseSql } from '../parse/parse.js'
 import { createMemorySource, createRowAccessor } from '../backend/memory.js'
 
@@ -14,8 +14,8 @@ import { createMemorySource, createRowAccessor } from '../backend/memory.js'
  * @param {ExecuteSqlOptions} options - the execution options
  * @returns {Record<string, any>[]} the result rows matching the query
  */
-export function executeSql({ source, sql }) {
-  const select = parseSql(sql)
+export function executeSql({ source, query }) {
+  const select = parseSql(query)
   const dataSource = Array.isArray(source) ? createMemorySource(source) : source
   return evaluateSelectAst(select, dataSource)
 }
@@ -142,6 +142,13 @@ 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
   /** @type {RowSource[]} */
   const working = []
@@ -244,8 +251,7 @@ function evaluateSelectAst(select, dataSource) {
       if (select.having) {
         // For HAVING, we need to evaluate aggregates in the context of the group
         // Create a special row context that includes both the group data and aggregate values
-        const havingContext = createHavingContext(resultRow, group)
-        if (!evaluateHavingExpr(select.having, havingContext, group)) {
+        if (!evaluateHavingExpr(select.having, resultRow, group)) {
           continue
         }
       }

package/src/execute/expression.js

@@ -190,5 +190,21 @@ export function evaluateExpr(node, row) {
     throw new Error('Unsupported CAST to type ' + node.toType)
   }
 
+  // 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/execute/having.js

@@ -12,7 +12,7 @@ import { evaluateExpr } from './expression.js'
  * @param {RowSource[]} group - the group of rows
  * @returns {RowSource} a context row for HAVING evaluation
  */
-export function createHavingContext(resultRow, group) {
+function createHavingContext(resultRow, group) {
   // Include the first row of the group (for GROUP BY columns)
   const firstRow = group[0]
   /** @type {Record<string, any>} */
@@ -41,11 +41,13 @@ export function createHavingContext(resultRow, group) {
  * Evaluates a HAVING expression with support for aggregate functions
  *
  * @param {ExprNode} expr - the HAVING expression
- * @param {RowSource} context - the context row with aggregated values
+ * @param {Record<string, any>} row - the aggregated result row
  * @param {RowSource[]} group - the group of rows for re-evaluating aggregates
  * @returns {boolean} whether the HAVING condition is satisfied
  */
-export function evaluateHavingExpr(expr, context, group) {
+export function evaluateHavingExpr(expr, row, group) {
+  const context = createHavingContext(row, group)
+
   // For HAVING, we need special handling of aggregate functions
   // They need to be re-evaluated against the group
   if (expr.type === 'function') {

package/src/index.d.ts

@@ -16,4 +16,4 @@ export function executeSql(options: ExecuteSqlOptions): Record<string, any>[]
  * @param sql - SQL query string to parse
  * @returns parsed SQL select statement
  */
-export function parseSql(sql: string): SelectStatement
+export function parseSql(query: string): SelectStatement

package/src/parse/expression.js

@@ -1,5 +1,5 @@
 /**
- * @import { ExprCursor, ExprNode, BinaryOp } from '../types.js'
+ * @import { ExprCursor, ExprNode, BinaryOp, SelectStatement } from '../types.js'
  */
 
 /**
@@ -111,6 +111,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 +134,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 +180,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 +275,37 @@ 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
+      if (!c.parseSubquery) {
+        throw new Error('Subquery parsing not available in this context')
+      }
+      const subquery = c.parseSubquery()
+      return {
+        type: 'not in',
+        expr: left,
+        subquery,
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'IN') {
+    c.consume() // IN
+    if (!c.parseSubquery) {
+      throw new Error('Subquery parsing not available in this context')
+    }
+    const subquery = c.parseSubquery()
+    return {
+      type: 'in',
+      expr: left,
+      subquery,
+    }
+  }
+
   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

@@ -10,15 +10,21 @@ export interface DataSource {
 
 export interface ExecuteSqlOptions {
   source: Record<string, any>[] | DataSource
-  sql: string
+  query: string
 }
 
 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,17 @@ export interface BetweenNode {
   upper: ExprNode
 }
 
+export interface InNode {
+  type: 'in' | 'not in'
+  expr: ExprNode
+  subquery: SelectStatement
+}
+
+export interface ExistsNode {
+  type: 'exists' | 'not exists'
+  subquery: SelectStatement
+}
+
 export type ExprNode =
   | LiteralNode
   | IdentifierNode
@@ -110,6 +127,8 @@ export type ExprNode =
   | FunctionNode
   | CastNode
   | BetweenNode
+  | InNode
+  | ExistsNode
 
 export interface StarColumn {
   kind: 'star'
@@ -184,4 +203,5 @@ export interface ExprCursor {
   match(type: TokenType, value?: string): boolean
   expect(type: TokenType, value: string): Token
   expectIdentifier(): Token
+  parseSubquery?: () => SelectStatement
 }