squirreling 0.12.0 → 0.12.1

package/README.md

@@ -35,7 +35,10 @@ const users = [
 
 // Squirreling return types
 interface QueryResults {
-  rows: () => AsyncGenerator<AsyncRow>
+  columns: string[]
+  numRows?: number
+  maxRows?: number
+  rows(): AsyncGenerator<AsyncRow>
 }
 interface AsyncRow {
   columns: string[]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -39,11 +39,11 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.5.0",
-    "@vitest/coverage-v8": "4.1.2",
+    "@types/node": "25.5.2",
+    "@vitest/coverage-v8": "4.1.3",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "62.9.0",
     "typescript": "6.0.2",
-    "vitest": "4.1.2"
+    "vitest": "4.1.3"
   }
 }

package/src/execute/aggregates.js

@@ -1,6 +1,6 @@
 import { derivedAlias } from '../expression/alias.js'
 import { evaluateExpr } from '../expression/evaluate.js'
-import { executePlan } from './execute.js'
+import { executePlan, selectColumnNames } from './execute.js'
 import { keyify } from './utils.js'
 
 /**
@@ -60,6 +60,7 @@ function projectAggregateColumns(selectColumns, group, context) {
 export function executeHashAggregate(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: selectColumnNames(plan.columns, child.columns),
     maxRows: child.maxRows,
     async *rows () {
       // Collect all rows
@@ -119,9 +120,11 @@ export function executeHashAggregate(plan, context) {
  */
 export function executeScalarAggregate(plan, context) {
   // Fast path: use scanColumn when available
+  const scalarColumns = selectColumnNames(plan.columns, [])
   const fast = tryColumnScanAggregate(plan, context)
   if (fast) {
     return {
+      columns: scalarColumns,
       numRows: 1,
       maxRows: 1,
       rows: fast,
@@ -130,6 +133,7 @@ export function executeScalarAggregate(plan, context) {
 
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: selectColumnNames(plan.columns, child.columns),
     numRows: plan.having ? undefined : 1,
     maxRows: 1,
     async *rows () {

package/src/execute/execute.js

@@ -10,7 +10,7 @@ import { executeSort } from './sort.js'
 import { addBounds, minBounds, stableRowKey } from './utils.js'
 
 /**
- * @import { AsyncCells, AsyncDataSource, AsyncRow, ExecuteContext, ExecuteSqlOptions, ExprNode, QueryResults, Statement } from '../types.js'
+ * @import { AsyncCells, AsyncDataSource, AsyncRow, ExecuteContext, ExecuteSqlOptions, ExprNode, QueryResults, SelectColumn, Statement } from '../types.js'
  * @import { CountNode, DistinctNode, FilterNode, LimitNode, ProjectNode, QueryPlan, ScanNode, SetOperationNode } from '../plan/types.js'
  */
 
@@ -88,7 +88,33 @@ export function executePlan({ plan, context }) {
   } else if (plan.type === 'SetOperation') {
     return executeSetOperation(plan, context)
   }
-  return { async *rows () {} }
+  return { columns: [], async *rows () {} }
+}
+
+/**
+ * Derives output column names from SELECT columns and available child columns.
+ *
+ * @param {SelectColumn[]} selectColumns
+ * @param {string[]} childColumns
+ * @returns {string[]}
+ */
+export function selectColumnNames(selectColumns, childColumns) {
+  /** @type {string[]} */
+  const result = []
+  for (const col of selectColumns) {
+    if (col.type === 'star') {
+      const prefix = col.table ? `${col.table}.` : undefined
+      for (const key of childColumns) {
+        if (prefix && !key.startsWith(prefix)) continue
+        const dotIndex = key.indexOf('.')
+        const outputKey = prefix ? key.substring(prefix.length) : dotIndex >= 0 ? key.substring(dotIndex + 1) : key
+        result.push(outputKey)
+      }
+    } else {
+      result.push(col.alias ?? derivedAlias(col.expr))
+    }
+  }
+  return result
 }
 
 /**
@@ -113,6 +139,7 @@ function executeScan(plan, context) {
     })
     const scanRows = computeScanRows(table.numRows, plan.hints.limit, plan.hints.offset)
     return {
+      columns: [column],
       numRows: scanRows,
       maxRows: scanRows,
       async *rows () {
@@ -142,6 +169,7 @@ function executeScan(plan, context) {
 
   const scanRows = computeScanRows(table.numRows, plan.hints.limit, plan.hints.offset)
   return {
+    columns: plan.hints.columns ?? table.columns,
     numRows: !plan.hints.where ? scanRows : undefined,
     maxRows: scanRows,
     async *rows () {
@@ -174,6 +202,7 @@ function executeCount(plan, context) {
   const table = validateTable({ ...plan, tables })
 
   return {
+    columns: plan.columns.map(col => col.alias ?? derivedAlias(col.expr)),
     numRows: 1,
     maxRows: 1,
     async *rows () {
@@ -300,6 +329,7 @@ async function* limitRows(rows, limit, offset, signal) {
 function executeFilter(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: child.columns,
     maxRows: child.maxRows,
     rows: () => filterRows(child.rows(), plan.condition, context),
   }
@@ -315,6 +345,7 @@ function executeFilter(plan, context) {
 function executeProject(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: selectColumnNames(plan.columns, child.columns),
     numRows: child.numRows,
     maxRows: child.maxRows,
     async *rows () {
@@ -369,6 +400,7 @@ function executeProject(plan, context) {
 function executeDistinct(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: child.columns,
     maxRows: child.maxRows,
     async *rows () {
       const { signal } = context
@@ -421,6 +453,7 @@ function executeDistinct(plan, context) {
 function executeLimit(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: child.columns,
     numRows: computeScanRows(child.numRows, plan.limit, plan.offset),
     maxRows: computeScanRows(child.maxRows, plan.limit, plan.offset),
     rows: () => limitRows(child.rows(), plan.limit, plan.offset, context.signal),
@@ -442,6 +475,7 @@ function executeSetOperation(plan, context) {
       const left = executePlan({ plan: plan.left, context })
       const right = executePlan({ plan: plan.right, context })
       return {
+        columns: left.columns,
         numRows: addBounds(left.numRows, right.numRows),
         maxRows: addBounds(left.maxRows, right.maxRows),
         async *rows () {
@@ -454,6 +488,7 @@ function executeSetOperation(plan, context) {
       const left = executePlan({ plan: plan.left, context })
       const right = executePlan({ plan: plan.right, context })
       return {
+        columns: left.columns,
         maxRows: addBounds(left.maxRows, right.maxRows),
         async *rows () {
           // UNION: yield deduplicated rows from both sides
@@ -481,6 +516,7 @@ function executeSetOperation(plan, context) {
     const left = executePlan({ plan: plan.left, context })
     const right = executePlan({ plan: plan.right, context })
     return {
+      columns: left.columns,
       maxRows: minBounds(left.maxRows, right.maxRows),
       async *rows () {
         // Materialize right side keys
@@ -522,6 +558,7 @@ function executeSetOperation(plan, context) {
     const left = executePlan({ plan: plan.left, context })
     const right = executePlan({ plan: plan.right, context })
     return {
+      columns: left.columns,
       maxRows: left.maxRows,
       async *rows () {
         // Materialize right side keys

package/src/execute/join.js

@@ -18,6 +18,7 @@ export function executeNestedLoopJoin(plan, context) {
   const left = executePlan({ plan: plan.left, context })
   const right = executePlan({ plan: plan.right, context })
   return {
+    columns: mergeColumnNames(left.columns, right.columns, plan.leftAlias, plan.rightAlias),
     async *rows () {
       const leftTable = plan.leftAlias
       const rightTable = plan.rightAlias
@@ -93,6 +94,7 @@ export function executePositionalJoin(plan, context) {
   const numRows = left.numRows !== undefined && right.numRows !== undefined
     ? Math.max(left.numRows, right.numRows) : undefined
   return {
+    columns: mergeColumnNames(left.columns, right.columns, plan.leftAlias, plan.rightAlias),
     numRows,
     maxRows: maxBounds(left.maxRows, right.maxRows),
     async *rows () {
@@ -140,6 +142,7 @@ export function executeHashJoin(plan, context) {
   const left = executePlan({ plan: plan.left, context })
   const right = executePlan({ plan: plan.right, context })
   return {
+    columns: mergeColumnNames(left.columns, right.columns, plan.leftAlias, plan.rightAlias),
     async *rows () {
       const leftTable = plan.leftAlias
       const rightTable = plan.rightAlias
@@ -233,6 +236,22 @@ function createNullRow(columns) {
   return { columns, cells }
 }
 
+/**
+ * Merges column name arrays with table prefixes, matching mergeRows logic.
+ *
+ * @param {string[]} leftColumns
+ * @param {string[]} rightColumns
+ * @param {string} leftTable
+ * @param {string} rightTable
+ * @returns {string[]}
+ */
+function mergeColumnNames(leftColumns, rightColumns, leftTable, rightTable) {
+  return [
+    ...leftColumns.map(c => c.includes('.') ? c : `${leftTable}.${c}`),
+    ...rightColumns.map(c => c.includes('.') ? c : `${rightTable}.${c}`),
+  ]
+}
+
 /**
  * Merges two rows into one, prefixing columns with table names
  *

package/src/execute/sort.js

@@ -17,6 +17,7 @@ import { compareForTerm } from './utils.js'
 export function executeSort(plan, context) {
   const child = executePlan({ plan: plan.child, context })
   return {
+    columns: child.columns,
     numRows: child.numRows,
     maxRows: child.maxRows,
     async *rows () {

package/src/types.d.ts

@@ -8,6 +8,7 @@ export { QueryPlan } from './plan/types.js'
  * Result of executing a SQL query.
  */
 export interface QueryResults {
+  columns: string[]
   rows(): AsyncGenerator<AsyncRow>
   numRows?: number
   maxRows?: number
@@ -68,7 +69,6 @@ export interface AsyncDataSource {
  */
 export interface ScanResults {
   rows(): AsyncIterable<AsyncRow>
-  numRows?: number // exact row count if known
   appliedWhere: boolean // WHERE filter applied at scan time?
   appliedLimitOffset: boolean // LIMIT and OFFSET applied at scan time?
 }