squirreling 0.12.4 → 0.12.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -43,7 +43,7 @@
     "@vitest/coverage-v8": "4.1.4",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "62.9.0",
-    "typescript": "6.0.2",
+    "typescript": "6.0.3",
     "vitest": "4.1.4"
   }
 }

package/src/parse/parse.js

@@ -1,3 +1,4 @@
+import { derivedAlias } from '../expression/alias.js'
 import { expectNoAggregate, findAggregate } from '../validation/aggregates.js'
 import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE } from '../validation/keywords.js'
 import { ParseError } from '../validation/parseErrors.js'
@@ -237,7 +238,7 @@ function parseSelect(state) {
   if (match(state, 'keyword', 'GROUP')) {
     expect(state, 'keyword', 'BY')
     while (true) {
-      const expr = parseExpression(state)
+      const expr = resolvePositionalRef(parseExpression(state), columns, 'GROUP BY')
       expectNoAggregate(expr, 'GROUP BY')
       groupBy.push(expr)
       if (!match(state, 'comma')) break
@@ -255,7 +256,7 @@ function parseSelect(state) {
   if (match(state, 'keyword', 'ORDER')) {
     expect(state, 'keyword', 'BY')
     while (true) {
-      const expr = parseExpression(state)
+      const expr = resolvePositionalRef(parseExpression(state), columns, 'ORDER BY', hasAggregate)
       if (!hasAggregate) {
         expectNoAggregate(expr, 'ORDER BY')
       }
@@ -333,6 +334,53 @@ function parseSelect(state) {
   }
 }
 
+/**
+ * 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
+ * pass through unchanged.
+ *
+ * In post-aggregation contexts (ORDER BY when the query aggregates), the
+ * reference resolves to an identifier on the output column name, so it
+ * matches columns produced by the aggregate projection. In pre-projection
+ * contexts (GROUP BY, non-aggregated ORDER BY), the target column's full
+ * expression is substituted, since the output name won't exist yet.
+ *
+ * @param {ExprNode} expr
+ * @param {SelectColumn[]} columns
+ * @param {string} clauseName
+ * @param {boolean} [postAgg]
+ * @returns {ExprNode}
+ */
+function resolvePositionalRef(expr, columns, clauseName, postAgg) {
+  if (expr.type !== 'literal') return expr
+  const n = expr.value
+  if (typeof n !== 'number' || !Number.isInteger(n) || n <= 0) return expr
+  if (n > columns.length) {
+    throw new ParseError({
+      message: `${clauseName} position ${n} is out of range (expected 1..${columns.length}) at position ${expr.positionStart}`,
+      positionStart: expr.positionStart,
+      positionEnd: expr.positionEnd,
+    })
+  }
+  const col = columns[n - 1]
+  if (col.type === 'star') {
+    throw new ParseError({
+      message: `${clauseName} position ${n} refers to * which is not supported at position ${expr.positionStart}`,
+      positionStart: expr.positionStart,
+      positionEnd: expr.positionEnd,
+    })
+  }
+  if (postAgg) {
+    return {
+      type: 'identifier',
+      name: col.alias ?? derivedAlias(col.expr),
+      positionStart: expr.positionStart,
+      positionEnd: expr.positionEnd,
+    }
+  }
+  return col.expr
+}
+
 /**
  * @param {ParserState} state
  * @returns {SelectColumn[]}

package/src/plan/columns.js

@@ -54,8 +54,19 @@ export function extractColumns({ select, parentColumns }) {
   // directly. For non-star queries, parent names may be aliases and are
   // handled below by filtering derived columns and collecting from expressions.
   const hasStar = select.columns.some(col => col.type === 'star' && !col.table)
+  // Exclude parent names that match a derived alias in this SELECT — those are
+  // produced by projection (e.g. `SELECT *, a+b AS c`), not by the source.
+  /** @type {Set<string>} */
+  const derivedAliases = new Set()
+  for (const col of select.columns) {
+    if (col.type === 'derived') {
+      derivedAliases.add(col.alias ?? derivedAlias(col.expr))
+    }
+  }
   /** @type {IdentifierNode[]} */
-  const identifiers = hasStar && parentColumns ? [...parentColumns] : []
+  const identifiers = hasStar && parentColumns
+    ? parentColumns.filter(id => !derivedAliases.has(id.name))
+    : []
 
   // Collect ORDER BY identifiers, excluding SELECT aliases (their underlying
   // columns are already collected from select.columns expressions above)