squirreling 0.1.1 → 0.1.2

package/README.md

@@ -1,11 +1,14 @@
 # Squirreling SQL Engine
 
+![squirreling engine](squirreling.jpg)
+
 [![npm](https://img.shields.io/npm/v/squirreling)](https://www.npmjs.com/package/squirreling)
 [![downloads](https://img.shields.io/npm/dt/squirreling)](https://www.npmjs.com/package/squirreling)
 [![minzipped](https://img.shields.io/bundlephobia/minzip/squirreling)](https://www.npmjs.com/package/squirreling)
 [![workflow status](https://github.com/hyparam/squirreling/actions/workflows/ci.yml/badge.svg)](https://github.com/hyparam/squirreling/actions)
 [![mit license](https://img.shields.io/badge/License-MIT-orange.svg)](https://opensource.org/licenses/MIT)
 [![dependencies](https://img.shields.io/badge/Dependencies-0-blueviolet)](https://www.npmjs.com/package/squirreling?activeTab=dependencies)
+
 Squirreling is a lightweight SQL engine for JavaScript applications, designed to provide efficient and easy-to-use database functionalities in the browser.
 
 ## Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
   "license": "MIT",

package/src/execute/execute.js

@@ -4,6 +4,7 @@
 
 import { defaultAggregateAlias, evaluateAggregate } from './aggregates.js'
 import { evaluateExpr } from './expression.js'
+import { createHavingContext, evaluateHavingExpr } from './having.js'
 import { parseSql } from '../parse/parse.js'
 
 /**
@@ -230,6 +231,17 @@ function evaluateSelectAst(select, rows) {
           continue
         }
       }
+
+      // Apply HAVING filter before adding to projected results
+      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)) {
+          continue
+        }
+      }
+
       projected.push(resultRow)
     }
   } else {

package/src/execute/expression.js

@@ -79,6 +79,21 @@ export function evaluateExpr(node, row) {
     }
   }
 
+  // BETWEEN and NOT BETWEEN
+  if (node.type === 'between' || node.type === 'not between') {
+    const expr = evaluateExpr(node.expr, row)
+    const lower = evaluateExpr(node.lower, row)
+    const upper = evaluateExpr(node.upper, row)
+
+    // If any value is NULL, return false (SQL behavior)
+    if (expr == null || lower == null || upper == null) {
+      return false
+    }
+
+    const isBetween = expr >= lower && expr <= upper
+    return node.type === 'between' ? isBetween : !isBetween
+  }
+
   // Function calls
   if (node.type === 'function') {
     const funcName = node.name.toUpperCase()

package/src/execute/having.js

@@ -0,0 +1,193 @@
+/**
+ * @import { ExprNode, Row, SqlPrimitive } from '../types.js'
+ */
+
+import { evaluateExpr } from './expression.js'
+
+/**
+ * Creates a context for evaluating HAVING expressions
+ * @param {Row} resultRow - The aggregated result row
+ * @param {Row[]} group - The group of rows
+ * @returns {Row} A context row for HAVING evaluation
+ */
+export function createHavingContext(resultRow, group) {
+  // Include the first row of the group (for GROUP BY columns)
+  const firstRow = group[0] || {}
+  // Merge with result row (which has aggregates computed)
+  return { ...firstRow, ...resultRow }
+}
+
+/**
+ * Evaluates a HAVING expression with support for aggregate functions
+ * @param {ExprNode} expr - The HAVING expression
+ * @param {Row} context - The context row with aggregated values
+ * @param {Row[]} group - The group of rows for re-evaluating aggregates
+ * @returns {boolean} Whether the HAVING condition is satisfied
+ */
+export function evaluateHavingExpr(expr, context, group) {
+  // For HAVING, we need special handling of aggregate functions
+  // They need to be re-evaluated against the group
+  if (expr.type === 'function') {
+    const funcName = expr.name.toUpperCase()
+    if (['COUNT', 'SUM', 'AVG', 'MIN', 'MAX'].includes(funcName)) {
+      // Evaluate aggregate function on the group
+      return Boolean(evaluateAggregateFunction(funcName, expr.args, group))
+    }
+  }
+
+  if (expr.type === 'binary') {
+    const left = evaluateHavingValue(expr.left, context, group)
+    const right = evaluateHavingValue(expr.right, context, group)
+
+    if (expr.op === 'AND') {
+      return Boolean(left && right)
+    }
+    if (expr.op === 'OR') {
+      return Boolean(left || right)
+    }
+
+    // Handle NULL comparisons
+    if (left == null || right == null) {
+      if (expr.op === '=' || expr.op === '!=' || expr.op === '<>') {
+        return false
+      }
+    }
+
+    if (expr.op === '=') return left === right
+    if (expr.op === '!=' || expr.op === '<>') return left !== right
+    if (expr.op === '<') return left < right
+    if (expr.op === '>') return left > right
+    if (expr.op === '<=') return left <= right
+    if (expr.op === '>=') return left >= right
+    if (expr.op === 'LIKE') {
+      const str = String(left)
+      const pattern = String(right)
+      const regexPattern = pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/%/g, '.*')
+        .replace(/_/g, '.')
+      const regex = new RegExp('^' + regexPattern + '$', 'i')
+      return regex.test(str)
+    }
+  }
+
+  if (expr.type === 'unary') {
+    if (expr.op === 'NOT') {
+      return !evaluateHavingExpr(expr.argument, context, group)
+    }
+    if (expr.op === 'IS NULL') {
+      return evaluateHavingValue(expr.argument, context, group) == null
+    }
+    if (expr.op === 'IS NOT NULL') {
+      return evaluateHavingValue(expr.argument, context, group) != null
+    }
+  }
+
+  if (expr.type === 'between' || expr.type === 'not between') {
+    const exprVal = evaluateHavingValue(expr.expr, context, group)
+    const lower = evaluateHavingValue(expr.lower, context, group)
+    const upper = evaluateHavingValue(expr.upper, context, group)
+
+    // If any value is NULL, return false (SQL behavior)
+    if (exprVal == null || lower == null || upper == null) {
+      return false
+    }
+
+    const isBetween = exprVal >= lower && exprVal <= upper
+    return expr.type === 'between' ? isBetween : !isBetween
+  }
+
+  // For other expression types, use the context row
+  return Boolean(evaluateExpr(expr, context))
+}
+
+/**
+ * Evaluates a value in a HAVING expression
+ * @param {ExprNode} expr - The expression
+ * @param {Row} context - The context row
+ * @param {Row[]} group - The group of rows
+ * @returns {SqlPrimitive} The evaluated value
+ */
+function evaluateHavingValue(expr, context, group) {
+  if (expr.type === 'function') {
+    const funcName = expr.name.toUpperCase()
+    if (['COUNT', 'SUM', 'AVG', 'MIN', 'MAX'].includes(funcName)) {
+      return evaluateAggregateFunction(funcName, expr.args, group)
+    }
+  }
+
+  // For binary expressions, we need to use evaluateHavingExpr to properly handle aggregates
+  if (expr.type === 'binary' || expr.type === 'unary' || expr.type === 'between' || expr.type === 'not between') {
+    return evaluateHavingExpr(expr, context, group)
+  }
+
+  return evaluateExpr(expr, context)
+}
+
+/**
+ * Evaluates an aggregate function on a group
+ * @param {string} funcName - The aggregate function name
+ * @param {ExprNode[]} args - The function arguments
+ * @param {Row[]} group - The group of rows
+ * @returns {SqlPrimitive} The aggregate result
+ */
+function evaluateAggregateFunction(funcName, args, group) {
+  if (funcName === 'COUNT') {
+    if (args.length === 1 && args[0].type === 'identifier' && args[0].name === '*') {
+      return group.length
+    }
+    // COUNT(column) - count non-null values
+    let count = 0
+    for (const row of group) {
+      const val = evaluateExpr(args[0], row)
+      if (val != null) count++
+    }
+    return count
+  }
+
+  if (funcName === 'SUM') {
+    let sum = 0
+    for (const row of group) {
+      const val = evaluateExpr(args[0], row)
+      if (val != null) sum += Number(val)
+    }
+    return sum
+  }
+
+  if (funcName === 'AVG') {
+    let sum = 0
+    let count = 0
+    for (const row of group) {
+      const val = evaluateExpr(args[0], row)
+      if (val != null) {
+        sum += Number(val)
+        count++
+      }
+    }
+    return count > 0 ? sum / count : null
+  }
+
+  if (funcName === 'MIN') {
+    let min = null
+    for (const row of group) {
+      const val = evaluateExpr(args[0], row)
+      if (val != null && (min == null || val < min)) {
+        min = val
+      }
+    }
+    return min
+  }
+
+  if (funcName === 'MAX') {
+    let max = null
+    for (const row of group) {
+      const val = evaluateExpr(args[0], row)
+      if (val != null && (max == null || val > max)) {
+        max = val
+      }
+    }
+    return max
+  }
+
+  throw new Error('Unsupported aggregate function: ' + funcName)
+}

package/src/parse/expression.js

@@ -42,8 +42,17 @@ export function parsePrimary(c) {
 
       if (c.current().type !== 'paren' || c.current().value !== ')') {
         while (true) {
-          const arg = parseExpression(c)
-          args.push(arg)
+          // Handle COUNT(*) - treat * as a special identifier
+          if (c.current().type === 'operator' && c.current().value === '*') {
+            c.consume()
+            args.push({
+              type: 'identifier',
+              name: '*',
+            })
+          } else {
+            const arg = parseExpression(c)
+            args.push(arg)
+          }
           if (!c.match('comma')) break
         }
       }
@@ -217,6 +226,37 @@ function parseComparison(c) {
     }
   }
 
+  // [NOT] BETWEEN
+  if (tok.type === 'keyword' && tok.value === 'NOT') {
+    const nextTok = c.peek(1)
+    if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
+      c.consume() // NOT
+      c.consume() // BETWEEN
+      const lower = parsePrimary(c)
+      c.expect('keyword', 'AND')
+      const upper = parsePrimary(c)
+      return {
+        type: 'not between',
+        expr: left,
+        lower,
+        upper,
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'BETWEEN') {
+    c.consume()
+    const lower = parsePrimary(c)
+    c.expect('keyword', 'AND')
+    const upper = parsePrimary(c)
+    return {
+      type: 'between',
+      expr: left,
+      lower,
+      upper,
+    }
+  }
+
   if (tok.type === 'operator' && isComparisonOperator(tok.value)) {
     c.consume()
     const right = parsePrimary(c)

package/src/parse/parse.js

@@ -407,6 +407,8 @@ function parseSelectInternal(state) {
   let where
   /** @type {ExprNode[]} */
   const groupBy = []
+  /** @type {ExprNode | undefined} */
+  let having
   /** @type {OrderByItem[]} */
   const orderBy = []
   /** @type {number | undefined} */
@@ -429,6 +431,10 @@ function parseSelectInternal(state) {
     }
   }
 
+  if (match(state, 'keyword', 'HAVING')) {
+    having = parseExpression(cursor)
+  }
+
   if (match(state, 'keyword', 'ORDER')) {
     expect(state, 'keyword', 'BY')
     while (true) {
@@ -497,6 +503,7 @@ function parseSelectInternal(state) {
     joins,
     where,
     groupBy,
+    having,
     orderBy,
     limit,
     offset,

package/src/types.d.ts

@@ -9,6 +9,7 @@ export interface SelectStatement {
   joins: JoinClause[]
   where?: ExprNode
   groupBy: ExprNode[]
+  having?: ExprNode
   orderBy: OrderByItem[]
   limit?: number
   offset?: number
@@ -81,7 +82,21 @@ export interface CastNode {
   toType: string
 }
 
-export type ExprNode = LiteralNode | IdentifierNode | UnaryNode | BinaryNode | FunctionNode | CastNode
+export interface BetweenNode {
+  type: 'between' | 'not between'
+  expr: ExprNode
+  lower: ExprNode
+  upper: ExprNode
+}
+
+export type ExprNode =
+  | LiteralNode
+  | IdentifierNode
+  | UnaryNode
+  | BinaryNode
+  | FunctionNode
+  | CastNode
+  | BetweenNode
 
 export interface StarColumn {
   kind: 'star'