squirreling 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,13 @@
 # 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.
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "squirreling",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/hyparam/squirrel.git"
+    "url": "git+https://github.com/hyparam/squirreling.git"
   },
   "type": "module",
   "sideEffects": false,

package/src/execute/aggregates.js

@@ -1,8 +1,9 @@
+import { evaluateExpr } from './expression.js'
 
 /**
  * Evaluates an aggregate function over a set of rows
  *
- * @import { AggregateColumn, Row } from '../types.js'
+ * @import { AggregateColumn, ExprNode, Row } from '../types.js'
  * @param {AggregateColumn} col - aggregate column definition
  * @param {Row[]} rows - rows to aggregate
  * @returns {number | null} aggregated result
@@ -12,10 +13,9 @@ export function evaluateAggregate(col, rows) {
 
   if (func === 'COUNT') {
     if (arg.kind === 'star') return rows.length
-    const field = arg.column
     let count = 0
     for (let i = 0; i < rows.length; i += 1) {
-      const v = rows[i][field]
+      const v = evaluateExpr(arg.expr, rows[i])
       if (v !== null && v !== undefined) {
         count += 1
       }
@@ -27,7 +27,6 @@ export function evaluateAggregate(col, rows) {
     if (arg.kind === 'star') {
       throw new Error(func + '(*) is not supported, use a column name')
     }
-    const field = arg.column
     let sum = 0
     let count = 0
     /** @type {number | null} */
@@ -36,7 +35,7 @@ export function evaluateAggregate(col, rows) {
     let max = null
 
     for (let i = 0; i < rows.length; i += 1) {
-      const raw = rows[i][field]
+      const raw = evaluateExpr(arg.expr, rows[i])
       if (raw == null) continue
       const num = Number(raw)
       if (!Number.isFinite(num)) continue
@@ -63,11 +62,39 @@ export function evaluateAggregate(col, rows) {
 
 /**
  * Generates a default alias name for an aggregate function
- * @param {AggregateColumn} col - The aggregate column definition
- * @returns {string} The generated alias (e.g., "count_all", "sum_amount")
+ * (e.g., "count_all", "sum_amount")
+ *
+ * @param {AggregateColumn} col
+ * @returns {string}
  */
 export function defaultAggregateAlias(col) {
   const base = col.func.toLowerCase()
   if (col.arg.kind === 'star') return base + '_all'
-  return base + '_' + col.arg.column
+  return base + '_' + defaultAggregateAliasExpr(col.arg.expr)
+}
+
+/**
+ * @param {ExprNode} expr
+ * @returns {string}
+ */
+export
+function defaultAggregateAliasExpr(expr) {
+  if (expr.type === 'identifier') {
+    return expr.name
+  }
+  if (expr.type === 'literal') {
+    return String(expr.value)
+  }
+  if (expr.type === 'cast') {
+    return defaultAggregateAliasExpr(expr.expr) + '_as_' + expr.toType
+  }
+  if (expr.type === 'unary') {
+    return expr.op + '_' + defaultAggregateAliasExpr(expr.argument)
+  }
+  if (expr.type === 'binary') {
+    return defaultAggregateAliasExpr(expr.left) + '_' + expr.op + '_' + defaultAggregateAliasExpr(expr.right)
+  }
+  if (expr.type === 'function') {
+    return expr.name.toLowerCase() + '_' + expr.args.map(defaultAggregateAliasExpr).join('_')
+  }
 }

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

@@ -226,11 +226,24 @@ function parseAggregateItem(state, func) {
   if (cur.type === 'operator' && cur.value === '*') {
     consume(state)
     arg = { kind: 'star' }
+  } else if (cur.type === 'identifier' && cur.value === 'CAST') {
+    // Handle CAST inside aggregate: SUM(CAST(x AS type))
+    expectIdentifier(state) // consume CAST
+    expect(state, 'paren', '(')
+    const cursor = createExprCursor(state)
+    const expr = parseExpression(cursor)
+    expect(state, 'keyword', 'AS')
+    const typeTok = expectIdentifier(state)
+    expect(state, 'paren', ')')
+    arg = {
+      kind: 'expression',
+      expr: { type: 'cast', expr, toType: typeTok.value },
+    }
   } else {
     const colTok = expectIdentifier(state)
     arg = {
-      kind: 'column',
-      column: colTok.value,
+      kind: 'expression',
+      expr: { type: 'identifier', name: colTok.value },
     }
   }
 
@@ -394,6 +407,8 @@ function parseSelectInternal(state) {
   let where
   /** @type {ExprNode[]} */
   const groupBy = []
+  /** @type {ExprNode | undefined} */
+  let having
   /** @type {OrderByItem[]} */
   const orderBy = []
   /** @type {number | undefined} */
@@ -416,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) {
@@ -484,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'
@@ -102,12 +117,12 @@ export interface AggregateArgStar {
   kind: 'star'
 }
 
-export interface AggregateArgColumn {
-  kind: 'column'
-  column: string
+export interface AggregateArgExpression {
+  kind: 'expression'
+  expr: ExprNode
 }
 
-export type AggregateArg = AggregateArgStar | AggregateArgColumn
+export type AggregateArg = AggregateArgStar | AggregateArgExpression
 
 export interface AggregateColumn {
   kind: 'aggregate'