squirreling 0.2.3 → 0.2.4

package/package.json

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

package/src/execute/expression.js

@@ -190,6 +190,24 @@ 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.')

package/src/parse/expression.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
@@ -281,28 +296,80 @@ function parseComparison(c) {
     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')
+
+      // 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 subquery = c.parseSubquery()
-      return {
-        type: 'not in',
-        expr: left,
-        subquery,
+      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
-    if (!c.parseSubquery) {
-      throw new Error('Subquery parsing not available in this context')
+
+    // 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 subquery = c.parseSubquery()
-    return {
-      type: 'in',
-      expr: left,
-      subquery,
+    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,
+      }
     }
   }
 

package/src/types.d.ts

@@ -108,12 +108,18 @@ export interface BetweenNode {
   upper: ExprNode
 }
 
-export interface InNode {
+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
@@ -127,7 +133,8 @@ export type ExprNode =
   | FunctionNode
   | CastNode
   | BetweenNode
-  | InNode
+  | InSubqueryNode
+  | InValuesNode
   | ExistsNode
 
 export interface StarColumn {