squirreling 0.11.2 → 0.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/execute/aggregates.js

@@ -244,7 +244,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   if (spec.funcName === 'COUNT' && spec.distinct) {
     const seen = new Set()
     for await (const chunk of values) {
-      if (signal?.aborted) return null
+      if (signal?.aborted) return
       for (let i = 0; i < chunk.length; i++) {
         const v = chunk[i]
         if (v == null) continue
@@ -257,7 +257,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   if (spec.funcName === 'COUNT') {
     let count = 0
     for await (const chunk of values) {
-      if (signal?.aborted) return null
+      if (signal?.aborted) return
       for (let i = 0; i < chunk.length; i++) {
         if (chunk[i] != null) count++
       }
@@ -274,7 +274,7 @@ async function scanColumnAggregate({ table, spec, limit, offset, signal }) {
   let max = null
 
   for await (const chunk of values) {
-    if (signal?.aborted) return null
+    if (signal?.aborted) return
     for (let i = 0; i < chunk.length; i++) {
       const v = chunk[i]
       if (v == null) continue

package/src/execute/execute.js

@@ -98,6 +98,29 @@ async function* executeScan(plan, context) {
   const table = validateTable({ ...plan, tables })
   validateScan({ ...plan, tables })
 
+  // Fast path: single column scan without WHERE
+  if (table.scanColumn && plan.hints.columns?.length === 1 && !plan.hints.where) {
+    const column = plan.hints.columns[0]
+    const chunks = table.scanColumn({
+      column,
+      limit: plan.hints.limit,
+      offset: plan.hints.offset,
+      signal,
+    })
+    const columns = [column]
+    for await (const chunk of chunks) {
+      if (signal?.aborted) return
+      for (let i = 0; i < chunk.length; i++) {
+        const value = chunk[i]
+        yield {
+          columns,
+          cells: { [column]: () => Promise.resolve(value) },
+        }
+      }
+    }
+    return
+  }
+
   // do the scan
   const { rows, appliedWhere, appliedLimitOffset } = table.scan({ ...plan.hints, signal })
 

package/src/parse/parse.js

@@ -169,19 +169,25 @@ function parseIntersectOperations(state) {
  */
 function parseSelect(state) {
   const { positionStart } = current(state)
-  expect(state, 'keyword', 'SELECT')
-
-  const distinct = match(state, 'keyword', 'DISTINCT')
-
-  const columns = parseSelectList(state)
+  /** @type {SelectColumn[]} */
+  let columns
+  let distinct = false
 
-  expect(state, 'keyword', 'FROM')
+  // Support duckdb-style shorthand "FROM table"
+  if (match(state, 'keyword', 'FROM')) {
+    columns = [{ type: 'star' }]
+  } else {
+    expect(state, 'keyword', 'SELECT')
+    distinct = match(state, 'keyword', 'DISTINCT')
+    columns = parseSelectList(state)
+    expect(state, 'keyword', 'FROM')
+  }
 
   // Check if it's a subquery or table name
   /** @type {FromTable | FromSubquery} */
   let from
-  const tok = current(state)
-  if (tok.type === 'paren' && tok.value === '(') {
+  const fromTok = current(state)
+  if (fromTok.type === 'paren' && fromTok.value === '(') {
     // Subquery: SELECT * FROM (SELECT ...) AS alias
     expect(state, 'paren', '(')
     const query = parseStatement(state)
@@ -191,7 +197,7 @@ function parseSelect(state) {
       type: 'subquery',
       query,
       alias,
-      positionStart: tok.positionStart,
+      positionStart: fromTok.positionStart,
       positionEnd: state.lastPos,
     }
   } else {
@@ -200,9 +206,9 @@ function parseSelect(state) {
     const alias = parseTableAlias(state)
     from = {
       type: 'table',
-      table: tok.value,
+      table: fromTok.value,
       alias,
-      positionStart: tok.positionStart,
+      positionStart: fromTok.positionStart,
       positionEnd: state.lastPos,
     }
   }

package/src/plan/columns.js

@@ -84,7 +84,7 @@ export function extractColumns({ select, parentColumns }) {
     collectColumnsFromExpr(item.expr, identifiers, selectAliases)
   }
   for (const expr of select.groupBy) {
-    collectColumnsFromExpr(expr, identifiers)
+    collectColumnsFromExpr(expr, identifiers, selectAliases)
   }
   collectColumnsFromExpr(select.having, identifiers, selectAliases)
   for (const join of select.joins) {

package/src/plan/plan.js

@@ -113,15 +113,25 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
   // Source alias for FROM clause
   const sourceAlias = fromAlias(select.from)
 
-  // Validate qualified references
+  // Validate qualified references and resolve aliases
   const scopeTables = Object.fromEntries([sourceAlias, ...select.joins.map(j => j.alias ?? j.table)].map(a => [a, true]))
-  for (const col of select.columns) {
+  /** @type {Map<string, ExprNode>} */
+  const aliases = new Map()
+  const columns = select.columns.map(col => {
     if (col.type === 'derived') {
       validateTableRefs(col.expr, scopeTables)
-    } else if (col.table && !(col.table in scopeTables)) {
+      const expr = resolveAliases(col.expr, aliases)
+      if (col.alias) {
+        aliases.set(col.alias, expr)
+      }
+      return { ...col, expr }
+    }
+    // Validate qualified references
+    if (col.table && !(col.table in scopeTables)) {
       throw new TableNotFoundError({ table: col.table, tables: scopeTables })
     }
-  }
+    return col
+  })
 
   // Determine scan hints for direct table scans (WHERE and LIMIT/OFFSET are
   // included so they are only applied to fresh scans, not CTE/subquery plans)
@@ -158,11 +168,15 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // Aggregation path: GROUP BY or scalar aggregate
     // HAVING is integrated into aggregate nodes for access to group context
     if (select.groupBy.length) {
-      plan = { type: 'HashAggregate', groupBy: select.groupBy, columns: select.columns, having: select.having, child: plan }
+      // Resolve SELECT aliases in GROUP BY expressions at plan time
+      const groupBy = aliases.size > 0
+        ? select.groupBy.map(expr => resolveAliases(expr, aliases))
+        : select.groupBy
+      plan = { type: 'HashAggregate', groupBy, columns, having: select.having, child: plan }
     } else if (!select.having && !select.where && plan.type === 'Scan' && isOwnScan && isAllCountStar(select.columns)) {
       plan = { type: 'Count', table: plan.table, columns: select.columns }
     } else {
-      plan = { type: 'ScalarAggregate', columns: select.columns, having: select.having, child: plan }
+      plan = { type: 'ScalarAggregate', columns, having: select.having, child: plan }
     }
 
     // ORDER BY (after aggregation)
@@ -185,13 +199,6 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // ORDER BY (before projection so it can access all columns)
     // Resolve SELECT aliases in ORDER BY expressions at plan time
     if (select.orderBy.length) {
-      /** @type {Map<string, ExprNode>} */
-      const aliases = new Map()
-      for (const col of select.columns) {
-        if (col.type === 'derived' && col.alias) {
-          aliases.set(col.alias, col.expr)
-        }
-      }
       const orderBy = aliases.size > 0
         ? select.orderBy.map(term => ({ ...term, expr: resolveAliases(term.expr, aliases) }))
         : select.orderBy
@@ -205,17 +212,7 @@ function planSelect({ select, ctePlans, cteColumns, tables, parentColumns }) {
     // Fast path for SELECT * without joins
     const isPassthrough = select.columns.length === 1 && select.columns[0].type === 'star' && !select.joins.length
     if (!isPassthrough) {
-      // Resolve earlier SELECT aliases in later column expressions
-      /** @type {Map<string, ExprNode>} */
-      const colAliases = new Map()
-      let projectColumns = select.columns.map(col => {
-        if (col.type !== 'derived') return col
-        const expr = resolveAliases(col.expr, colAliases)
-        if (col.alias) {
-          colAliases.set(col.alias, expr)
-        }
-        return { ...col, expr }
-      })
+      let projectColumns = columns
       // When parent only needs specific columns, drop unneeded projections
       if (parentColumns) {
         projectColumns = projectColumns.filter(col =>

package/src/types.d.ts

@@ -1,4 +1,4 @@
-import type { ExprNode, SelectStatement, SqlPrimitive, Statement } from './ast.js'
+import type { ExprNode, SqlPrimitive, Statement } from './ast.js'
 
 export * from './ast.js'
 export { ParserState, Token, TokenType } from './parse/types.js'