squirreling 0.1.0 → 0.1.1

package/README.md

@@ -1,7 +1,11 @@
 # Squirreling SQL Engine
 
+[![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,12 +1,12 @@
 {
   "name": "squirreling",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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/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 },
     }
   }
 

package/src/types.d.ts

@@ -102,12 +102,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'