squirreling 0.16.3 → 0.16.4

package/README.md

@@ -95,10 +95,10 @@ Because Squirreling uses lazy cell evaluation, the `AI_SCORE` function only exec
 
 ### Custom Data Sources
 
-Squirreling can work with any data source that implements the `AsyncDataSource` interface.
+Squirreling can work with any data source that implements the `AsyncDataSource` interface. The simplest form is a `ScannableDataSource`: column names plus a row scan.
 
 ```typescript
-interface AsyncDataSource {
+interface ScannableDataSource {
   numRows?: number
   columns: string[]
   scan(options: ScanOptions): ScanResults
@@ -144,7 +144,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - `WITH` clause for Common Table Expressions (CTEs)
 - Subqueries in `SELECT`, `FROM`, `WHERE`, and correlated subqueries
 - `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`, `CROSS JOIN`, `POSITIONAL JOIN`, `LATERAL VIEW [OUTER] EXPLODE(...)`, with `ON` or `USING (col, ...)` conditions
-- `GROUP BY` and `HAVING` clauses
+- `GROUP BY` and `HAVING` clauses, including `GROUP BY ALL`
 - Set operations: `UNION`, `UNION ALL`, `INTERSECT`, `INTERSECT ALL`, `EXCEPT`, `EXCEPT ALL`
 - Expressions: `CASE`, `CAST`, `TRY_CAST`, `BETWEEN`, `IN`, `LIKE`, `IS NULL`, `IS NOT NULL`, string concatenation `||`
 - Subscript access: zero-based array indexing `col[0]`, struct field access `col['field']`, and chains like `col[0].field`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -39,11 +39,13 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "26.4.0",
-    "@vitest/coverage-v8": "4.1.11",
-    "eslint": "9.39.4",
-    "eslint-plugin-jsdoc": "64.2.1",
+    "@eslint/js": "10.0.1",
+    "@types/node": "26.4.1",
+    "@vitest/coverage-v8": "5.0.0",
+    "eslint": "10.10.0",
+    "eslint-plugin-jsdoc": "64.3.6",
+    "globals": "17.12.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   }
 }

package/src/execute/execute.js

@@ -588,7 +588,9 @@ function executeCount(plan, context) {
           throw new Error(`Data source "${plan.table}" does not implement scan()`)
         }
         let count = 0
-        const { rows } = table.scan({ signal })
+        // Counting needs row presence, not payload columns. Sources may still
+        // read columns required for their own visibility or delete filters.
+        const { rows } = table.scan({ columns: [], signal })
         // eslint-disable-next-line no-unused-vars
         for await (const _ of rows()) {
           signal?.throwIfAborted()

package/src/index.d.ts

@@ -1,8 +1,10 @@
-import type { AsyncBatch, AsyncDataSource, AsyncRow, ColumnResult, ColumnVector, ExecuteContext, ExecuteSqlOptions, ExprNode, ParseSqlOptions, PlanSqlOptions, QueryPlan, QueryResults, ReadBatchColumnOptions, RowsToBatchesOptions, RowSelection, SqlPrimitive, Statement, Token } from './types.js'
+import type { AsyncBatch, AsyncDataSource, AsyncRow, PreparableDataSource, ScannableDataSource, ColumnResult, ColumnVector, ExecuteContext, ExecuteSqlOptions, ExprNode, ParseSqlOptions, PlanSqlOptions, QueryPlan, QueryResults, ReadBatchColumnOptions, RowsToBatchesOptions, RowSelection, SqlPrimitive, Statement, Token } from './types.js'
 export type {
   AsyncBatch,
   AsyncCells,
   AsyncDataSource,
+  PreparableDataSource,
+  ScannableDataSource,
   AsyncRow,
   BatchColumn,
   ColumnDemand,

package/src/parse/parse.js

@@ -274,11 +274,16 @@ function parseSelect(state) {
 
   if (match(state, 'keyword', 'GROUP')) {
     expect(state, 'keyword', 'BY')
-    while (true) {
-      const expr = resolvePositionalRef(parseExpression(state), columns, 'GROUP BY')
-      expectNoAggregate(expr, 'GROUP BY')
-      groupBy.push(expr)
-      if (!match(state, 'comma')) break
+    if (current(state).type === 'keyword' && current(state).value === 'ALL') {
+      const tok = consume(state)
+      groupBy.push(...expandGroupByAll(columns, tok.positionStart, tok.positionEnd))
+    } else {
+      while (true) {
+        const expr = resolvePositionalRef(parseExpression(state), columns, 'GROUP BY')
+        expectNoAggregate(expr, 'GROUP BY')
+        groupBy.push(expr)
+        if (!match(state, 'comma')) break
+      }
     }
   }
 
@@ -371,6 +376,30 @@ function parseSelect(state) {
   }
 }
 
+/**
+ * Expand GROUP BY ALL into every SELECT expression that contains no aggregate.
+ *
+ * @param {SelectColumn[]} columns
+ * @param {number} positionStart
+ * @param {number} positionEnd
+ * @returns {ExprNode[]}
+ */
+function expandGroupByAll(columns, positionStart, positionEnd) {
+  /** @type {ExprNode[]} */
+  const groupBy = []
+  for (const col of columns) {
+    if (col.type === 'star') {
+      throw new ParseError({
+        message: `GROUP BY ALL does not support * at position ${positionStart}`,
+        positionStart,
+        positionEnd,
+      })
+    }
+    if (!findAggregate(col.expr)) groupBy.push(col.expr)
+  }
+  return groupBy
+}
+
 /**
  * Resolves a positive integer literal in GROUP BY or ORDER BY as a positional
  * reference to the Nth SELECT column. Non-integer and non-literal expressions

package/src/types.d.ts

@@ -209,30 +209,33 @@ export type AsyncCell = () => Promise<SqlPrimitive>
 
 export type Row = Record<string, SqlPrimitive>[]
 
-/**
- * Async data source for streaming SQL execution. A source must implement
- * either scan() or prepareScan().
- */
 interface AsyncDataSourceBase {
   numRows?: number
   // Optional method for fast column scans
   scanColumn?(options: ScanColumnOptions): AsyncIterable<ArrayLike<SqlPrimitive>> | ScanColumnResults
 }
 
-export type AsyncDataSource = AsyncDataSourceBase & (
-  | {
-      columns: string[]
-      scan(options: ScanOptions): ScanResults
-      schema?: RelationSchema
-      prepareScan?: PrepareScan
-    }
-  | {
-      columns?: string[]
-      scan?(options: ScanOptions): ScanResults
-      schema: RelationSchema
-      prepareScan: PrepareScan
-    }
-)
+/** A data source that always provides column names and a row scan. */
+export interface ScannableDataSource extends AsyncDataSourceBase {
+  columns: string[]
+  scan(options: ScanOptions): ScanResults
+  schema?: RelationSchema
+  prepareScan?: PrepareScan
+}
+
+/** A data source that always provides a schema and a prepared batch scan. */
+export interface PreparableDataSource extends AsyncDataSourceBase {
+  columns?: string[]
+  scan?(options: ScanOptions): ScanResults
+  schema: RelationSchema
+  prepareScan: PrepareScan
+}
+
+/**
+ * Async data source for streaming SQL execution. A source must implement
+ * either scan() or prepareScan().
+ */
+export type AsyncDataSource = ScannableDataSource | PreparableDataSource
 
 /**
  * Result of a scan: streaming rows and flags indicating which hints were