squirreling 0.8.0 → 0.9.0

package/src/plan/types.d.ts

@@ -1,30 +1,26 @@
-import { AsyncDataSource, ExprNode, JoinType, OrderByItem, ScanOptions, SelectColumn, UserDefinedFunction } from '../types.js'
-
-export interface ExecuteContext {
-  tables: Record<string, AsyncDataSource>
-  functions?: Record<string, UserDefinedFunction>
-  signal?: AbortSignal
-}
+import { ExprNode, JoinType, OrderByItem, ScanOptions, SelectColumn } from '../types.js'
 
 export type QueryPlan =
   | ScanNode
   | FilterNode
   | ProjectNode
-  | HashJoinNode
-  | NestedLoopJoinNode
-  | PositionalJoinNode
-  | HashAggregateNode
-  | ScalarAggregateNode
   | SortNode
   | DistinctNode
   | LimitNode
+  | HashAggregateNode
+  | ScalarAggregateNode
+  | HashJoinNode
+  | NestedLoopJoinNode
+  | PositionalJoinNode
 
+// Scan node
 export interface ScanNode {
   type: 'Scan'
   table: string
-  hints?: ScanOptions
+  hints: ScanOptions
 }
 
+// Single-child nodes
 export interface FilterNode {
   type: 'Filter'
   condition: ExprNode
@@ -37,6 +33,41 @@ export interface ProjectNode {
   child: QueryPlan
 }
 
+export interface SortNode {
+  type: 'Sort'
+  orderBy: OrderByItem[]
+  child: QueryPlan
+}
+
+export interface DistinctNode {
+  type: 'Distinct'
+  child: QueryPlan
+}
+
+export interface LimitNode {
+  type: 'Limit'
+  limit?: number
+  offset?: number
+  child: QueryPlan
+}
+
+// Aggregate nodes
+export interface HashAggregateNode {
+  type: 'HashAggregate'
+  groupBy: ExprNode[]
+  columns: SelectColumn[]
+  having?: ExprNode
+  child: QueryPlan
+}
+
+export interface ScalarAggregateNode {
+  type: 'ScalarAggregate'
+  columns: SelectColumn[]
+  having?: ExprNode
+  child: QueryPlan
+}
+
+// Join nodes
 export interface HashJoinNode {
   type: 'HashJoin'
   joinType: JoinType
@@ -65,37 +96,3 @@ export interface PositionalJoinNode {
   left: QueryPlan
   right: QueryPlan
 }
-
-export interface HashAggregateNode {
-  type: 'HashAggregate'
-  groupBy: ExprNode[]
-  columns: SelectColumn[]
-  having?: ExprNode
-  child: QueryPlan
-}
-
-export interface ScalarAggregateNode {
-  type: 'ScalarAggregate'
-  columns: SelectColumn[]
-  having?: ExprNode
-  child: QueryPlan
-}
-
-export interface SortNode {
-  type: 'Sort'
-  orderBy: OrderByItem[]
-  aliases?: Map<string, ExprNode>
-  child: QueryPlan
-}
-
-export interface DistinctNode {
-  type: 'Distinct'
-  child: QueryPlan
-}
-
-export interface LimitNode {
-  type: 'Limit'
-  limit?: number
-  offset?: number
-  child: QueryPlan
-}

package/src/types.d.ts

@@ -15,6 +15,19 @@ export interface ExecuteSqlOptions {
   signal?: AbortSignal
 }
 
+// planSql(options)
+export interface PlanSqlOptions {
+  query: string | SelectStatement
+  functions?: Record<string, UserDefinedFunction>
+}
+
+// executePlan(plan, context)
+export interface ExecuteContext {
+  tables: Record<string, AsyncDataSource>
+  functions?: Record<string, UserDefinedFunction>
+  signal?: AbortSignal
+}
+
 // AsyncRow represents a row with async cell values
 export interface AsyncRow {
   columns: string[]
@@ -285,3 +298,9 @@ export interface JoinClause {
   alias?: string
   on?: ExprNode
 }
+
+export interface ExecuteContext {
+  tables: Record<string, AsyncDataSource>
+  functions?: Record<string, UserDefinedFunction>
+  signal?: AbortSignal
+}

package/src/validationErrors.js

@@ -89,15 +89,20 @@ export function argValueError({ funcName, message, positionStart, positionEnd, h
 }
 
 /**
- * Error for aggregate function misuse (e.g., SUM(*)).
+ * Error for aggregate function misuse.
  *
  * @param {Object} options
  * @param {string} options.funcName - The aggregate function
- * @param {string} options.issue - What's wrong (e.g., "(*) is not supported")
- * @returns {Error}
+ * @param {number} options.positionStart - Start position in query
+ * @param {number} options.positionEnd - End position in query
+ * @returns {ExecutionError}
  */
-export function aggregateError({ funcName, issue }) {
-  return new Error(`${funcName}${issue}`)
+export function aggregateError({ funcName, positionStart, positionEnd }) {
+  return new ExecutionError({
+    message: `Aggregate function ${funcName} must exist in a GROUP BY clause or be part of an aggregate SELECT list`,
+    positionStart,
+    positionEnd,
+  })
 }
 
 /**

package/src/execute/columns.js

@@ -1,102 +0,0 @@
-/**
- * @import { ExprNode, SelectStatement, SelectColumn } from '../types.js'
- */
-
-/**
- * Extracts column names needed from a SELECT statement.
- *
- * @param {SelectStatement} select
- * @returns {string[] | undefined} array of column names, or undefined if all columns needed
- */
-export function extractColumns(select) {
-  // If any column is SELECT *, we need all columns
-  if (select.columns.some(col => col.kind === 'star')) {
-    return undefined
-  }
-
-  /** @type {Set<string>} */
-  const columns = new Set()
-
-  // Columns from SELECT list
-  for (const col of select.columns) {
-    collectColumnsFromSelectColumn(col, columns)
-  }
-
-  // Columns from WHERE
-  collectColumnsFromExpr(select.where, columns)
-
-  // Columns from ORDER BY
-  for (const item of select.orderBy) {
-    collectColumnsFromExpr(item.expr, columns)
-  }
-
-  // Columns from GROUP BY
-  for (const expr of select.groupBy) {
-    collectColumnsFromExpr(expr, columns)
-  }
-
-  // Columns from HAVING
-  collectColumnsFromExpr(select.having, columns)
-
-  return [...columns]
-}
-
-/**
- * Collects column names from a SELECT column
- *
- * @param {SelectColumn} col
- * @param {Set<string>} columns
- */
-function collectColumnsFromSelectColumn(col, columns) {
-  if (col.kind === 'derived') {
-    collectColumnsFromExpr(col.expr, columns)
-  }
-  // 'star' columns handled separately (returns undefined for all columns)
-}
-
-/**
- * Recursively collects column names (identifiers) from an expression
- *
- * @param {ExprNode | undefined} expr
- * @param {Set<string>} columns
- */
-function collectColumnsFromExpr(expr, columns) {
-  if (!expr) return
-  if (expr.type === 'identifier' && expr.name !== '*') {
-    columns.add(expr.name)
-  } else if (expr.type === 'literal') {
-    // No columns
-  } else if (expr.type === 'binary') {
-    collectColumnsFromExpr(expr.left, columns)
-    collectColumnsFromExpr(expr.right, columns)
-  } else if (expr.type === 'unary') {
-    collectColumnsFromExpr(expr.argument, columns)
-  } else if (expr.type === 'function') {
-    for (const arg of expr.args) {
-      collectColumnsFromExpr(arg, columns)
-    }
-  } else if (expr.type === 'cast') {
-    collectColumnsFromExpr(expr.expr, columns)
-  } else if (expr.type === 'in valuelist') {
-    collectColumnsFromExpr(expr.expr, columns)
-    for (const val of expr.values) {
-      collectColumnsFromExpr(val, columns)
-    }
-  } else if (expr.type === 'in') {
-    collectColumnsFromExpr(expr.expr, columns)
-    // Subquery columns are from a different scope, don't collect
-  } else if (expr.type === 'exists' || expr.type === 'not exists') {
-    // Subquery columns are from a different scope, don't collect
-  } else if (expr.type === 'case') {
-    if (expr.caseExpr) {
-      collectColumnsFromExpr(expr.caseExpr, columns)
-    }
-    for (const when of expr.whenClauses) {
-      collectColumnsFromExpr(when.condition, columns)
-      collectColumnsFromExpr(when.result, columns)
-    }
-    if (expr.elseResult) {
-      collectColumnsFromExpr(expr.elseResult, columns)
-    }
-  }
-}