squirreling 0.2.5 → 0.2.6

package/package.json

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

package/src/execute/expression.js

@@ -224,5 +224,34 @@ export function evaluateExpr(node, row) {
     throw new Error('WHERE NOT EXISTS with subqueries is not yet supported.')
   }
 
+  // CASE expressions
+  if (node.type === 'case') {
+    // For simple CASE: evaluate the case expression once
+    const caseValue = node.caseExpr ? evaluateExpr(node.caseExpr, row) : undefined
+
+    // Iterate through WHEN clauses
+    for (const whenClause of node.whenClauses) {
+      let conditionResult
+      if (caseValue !== undefined) {
+        // Simple CASE: compare caseValue with condition
+        const whenValue = evaluateExpr(whenClause.condition, row)
+        conditionResult = caseValue === whenValue
+      } else {
+        // Searched CASE: evaluate condition as boolean
+        conditionResult = evaluateExpr(whenClause.condition, row)
+      }
+
+      if (conditionResult) {
+        return evaluateExpr(whenClause.result, row)
+      }
+    }
+
+    // No WHEN clause matched, return ELSE result or NULL
+    if (node.elseResult) {
+      return evaluateExpr(node.elseResult, row)
+    }
+    return null
+  }
+
   throw new Error('Unknown expression node type ' + node.type)
 }

package/src/parse/expression.js

@@ -141,6 +141,48 @@ function parsePrimary(c) {
         subquery,
       }
     }
+    if (tok.value === 'CASE') {
+      c.consume() // CASE
+
+      // Check if it's simple CASE (CASE expr WHEN ...) or searched CASE (CASE WHEN ...)
+      /** @type {import('../types.js').ExprNode | undefined} */
+      let caseExpr
+      const nextTok = c.current()
+      if (nextTok.type !== 'keyword' || nextTok.value !== 'WHEN') {
+        // Simple CASE: parse the case expression
+        caseExpr = parseExpression(c)
+      }
+
+      // Parse WHEN clauses
+      /** @type {import('../types.js').WhenClause[]} */
+      const whenClauses = []
+      while (c.match('keyword', 'WHEN')) {
+        const condition = parseExpression(c)
+        c.expect('keyword', 'THEN')
+        const result = parseExpression(c)
+        whenClauses.push({ condition, result })
+      }
+
+      if (whenClauses.length === 0) {
+        throw new Error('CASE expression must have at least one WHEN clause')
+      }
+
+      // Parse optional ELSE clause
+      /** @type {import('../types.js').ExprNode | undefined} */
+      let elseResult
+      if (c.match('keyword', 'ELSE')) {
+        elseResult = parseExpression(c)
+      }
+
+      c.expect('keyword', 'END')
+
+      return {
+        type: 'case',
+        caseExpr,
+        whenClauses,
+        elseResult,
+      }
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {

package/src/parse/parse.js

@@ -177,7 +177,7 @@ function parseSelectList(state) {
 function parseSelectItem(state) {
   const tok = current(state)
 
-  if (tok.type !== 'identifier' && tok.type !== 'operator') {
+  if (tok.type === 'keyword' && tok.value !== 'CASE' || tok.type === 'eof') {
     throw parseError(state, 'column name or expression')
   }
 

package/src/types.d.ts

@@ -105,6 +105,18 @@ export interface ExistsNode {
   subquery: SelectStatement
 }
 
+export interface WhenClause {
+  condition: ExprNode
+  result: ExprNode
+}
+
+export interface CaseNode {
+  type: 'case'
+  caseExpr?: ExprNode
+  whenClauses: WhenClause[]
+  elseResult?: ExprNode
+}
+
 export type ExprNode =
   | LiteralNode
   | IdentifierNode
@@ -116,6 +128,7 @@ export type ExprNode =
   | InSubqueryNode
   | InValuesNode
   | ExistsNode
+  | CaseNode
 
 export interface StarColumn {
   kind: 'star'