squirreling 0.4.2 → 0.4.4

package/README.md

@@ -29,7 +29,7 @@ Squirreling is a streaming async SQL engine for JavaScript. It is designed to pr
 
 Squirreling returns an async generator, allowing you to process rows one at a time without loading everything into memory.
 
-```javascript
+```typescript
 import { executeSql } from 'squirreling'
 
 // In-memory table
@@ -40,12 +40,18 @@ const users = [
   // ...more rows
 ]
 
-// Process rows as they arrive (streaming)
-for await (const { cnt } of executeSql({
+type AsyncRow = Record<string, AsyncCell>
+type AsyncCell = () => Promise<SqlPrimitive>
+
+// Returns an async iterable of rows with async cells
+const asyncRows: AsyncIterable<AsyncRow> = executeSql({
   tables: { users },
   query: 'SELECT count(*) as cnt FROM users WHERE active = TRUE LIMIT 10',
-})) {
-  console.log('Count', cnt)
+})
+
+// Process rows as they arrive (streaming)
+for await (const { cnt } of asyncRows) {
+  console.log('Count', await cnt())
 }
 ```
 
@@ -54,7 +60,8 @@ There is an exported helper function `collect` to gather all rows into an array
 ```javascript
 import { collect, executeSql } from 'squirreling'
 
-const allUsers = await collect(executeSql({
+// Collect all rows and cells into a materialized array
+const allUsers: Record<string, SqlPrimitive>[] = await collect(executeSql({
   tables: { users },
   query: 'SELECT * FROM users',
 }))

package/package.json

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

package/src/execute/aggregates.js

@@ -16,6 +16,16 @@ export async function evaluateAggregate({ col, rows, tables }) {
 
   if (func === 'COUNT') {
     if (arg.kind === 'star') return rows.length
+    if (arg.quantifier === 'distinct') {
+      const seen = new Set()
+      for (const row of rows) {
+        const v = await evaluateExpr({ node: arg.expr, row, tables })
+        if (v !== null && v !== undefined) {
+          seen.add(v)
+        }
+      }
+      return seen.size
+    }
     let count = 0
     for (const row of rows) {
       const v = await evaluateExpr({ node: arg.expr, row, tables })

package/src/execute/columns.js

@@ -0,0 +1,107 @@
+/**
+ * @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)
+  } else if (col.kind === 'aggregate') {
+    if (col.arg.kind === 'expression') {
+      collectColumnsFromExpr(col.arg.expr, columns)
+    }
+    // 'star' aggregate (COUNT(*)) doesn't reference specific 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') {
+    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)
+    }
+  }
+}

package/src/execute/execute.js

@@ -5,9 +5,10 @@ import { evaluateExpr } from './expression.js'
 import { evaluateHavingExpr } from './having.js'
 import { executeJoins } from './join.js'
 import { compareForTerm, defaultDerivedAlias } from './utils.js'
+import { extractColumns } from './columns.js'
 
 /**
- * @import { AsyncDataSource, ExecuteSqlOptions, ExprNode, OrderByItem, AsyncRow, SelectStatement, SqlPrimitive } from '../types.js'
+ * @import { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ExprNode, OrderByItem, QueryHints, SelectStatement, SqlPrimitive } from '../types.js'
  */
 
 /**
@@ -239,7 +240,16 @@ async function* evaluateStreaming(select, dataSource, tables) {
   /** @type {Set<string> | undefined} */
   const seen = select.distinct ? new Set() : undefined
 
-  for await (const row of dataSource.getRows()) {
+  // hints for data source optimization
+  /** @type {QueryHints} */
+  const hints = {
+    columns: extractColumns(select),
+    where: select.where,
+    limit: select.limit,
+    offset: select.offset,
+  }
+
+  for await (const row of dataSource.getRows(hints)) {
     // WHERE filter
     if (select.where) {
       const pass = await evaluateExpr({ node: select.where, row, tables })
@@ -301,10 +311,18 @@ async function* evaluateStreaming(select, dataSource, tables) {
  * @yields {AsyncRow}
  */
 async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGrouping) {
+  // Build hints for data source optimization
+  // Note: limit/offset not passed here since buffering needs all rows for sorting/grouping
+  /** @type {QueryHints} */
+  const hints = {
+    where: select.where,
+    columns: extractColumns(select),
+  }
+
   // Step 1: Collect all rows from data source
   /** @type {AsyncRow[]} */
   const working = []
-  for await (const row of dataSource.getRows()) {
+  for await (const row of dataSource.getRows(hints)) {
     working.push(row)
   }
 

package/src/execute/expression.js

@@ -210,7 +210,7 @@ export async function evaluateExpr({ node, row, tables }) {
       if (isNaN(num)) return null
       return num
     }
-    if (toType === 'TEXT' || toType === 'STRING') {
+    if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
       return String(val)
     }
     if (toType === 'BOOLEAN' || toType === 'BOOL') {

package/src/index.d.ts

@@ -1,4 +1,4 @@
-import type { AsyncRow, ExecuteSqlOptions, SelectStatement, SqlPrimitive } from './types.js'
+import type { AsyncDataSource, AsyncRow, ExecuteSqlOptions, SelectStatement, SqlPrimitive } from './types.js'
 export type { AsyncDataSource, AsyncRow, SqlPrimitive } from './types.js'
 
 /**
@@ -26,3 +26,5 @@ export function parseSql(query: string): SelectStatement
  * @returns array of all yielded values
  */
 export function collect<T>(asyncGen: AsyncGenerator<AsyncRow>): Promise<Record<string, SqlPrimitive>[]>
+
+export function cachedDataSource(source: AsyncDataSource): AsyncDataSource

package/src/index.js

@@ -1,3 +1,4 @@
 export { executeSql } from './execute/execute.js'
 export { parseSql } from './parse/parse.js'
 export { collect } from './execute/utils.js'
+export { cachedDataSource } from './backend/dataSource.js'

package/src/parse/comparison.js

@@ -0,0 +1,198 @@
+import { isBinaryOp } from '../validation.js'
+import { parseExpression, parsePrimary } from './expression.js'
+
+/**
+ * @import { ExprCursor, ExprNode } from '../types.js'
+ */
+
+/**
+ * @param {ExprCursor} c
+ * @returns {ExprNode}
+ */
+export function parseComparison(c) {
+  const left = parsePrimary(c)
+  const tok = c.current()
+
+  // IS [NOT] NULL
+  if (tok.type === 'keyword' && tok.value === 'IS') {
+    c.consume()
+    const notToken = c.current()
+    if (notToken.type === 'keyword' && notToken.value === 'NOT') {
+      c.consume()
+      c.expect('keyword', 'NULL')
+      return {
+        type: 'unary',
+        op: 'IS NOT NULL',
+        argument: left,
+      }
+    }
+    c.expect('keyword', 'NULL')
+    return {
+      type: 'unary',
+      op: 'IS NULL',
+      argument: left,
+    }
+  }
+
+  // [NOT] LIKE
+  if (tok.type === 'keyword' && tok.value === 'NOT') {
+    const nextTok = c.peek(1)
+    if (nextTok.type === 'keyword' && nextTok.value === 'LIKE') {
+      c.consume() // NOT
+      c.consume() // LIKE
+      const right = parsePrimary(c)
+      return {
+        type: 'unary',
+        op: 'NOT',
+        argument: {
+          type: 'binary',
+          op: 'LIKE',
+          left,
+          right,
+        },
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'LIKE') {
+    c.consume()
+    const right = parsePrimary(c)
+    return {
+      type: 'binary',
+      op: 'LIKE',
+      left,
+      right,
+    }
+  }
+
+  // [NOT] BETWEEN - convert to range comparison
+  if (tok.type === 'keyword' && tok.value === 'NOT') {
+    const nextTok = c.peek(1)
+    if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
+      c.consume() // NOT
+      c.consume() // BETWEEN
+      const lower = parsePrimary(c)
+      c.expect('keyword', 'AND')
+      const upper = parsePrimary(c)
+      // NOT BETWEEN -> expr < lower OR expr > upper
+      return {
+        type: 'binary',
+        op: 'OR',
+        left: { type: 'binary', op: '<', left, right: lower },
+        right: { type: 'binary', op: '>', left, right: upper },
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'BETWEEN') {
+    c.consume()
+    const lower = parsePrimary(c)
+    c.expect('keyword', 'AND')
+    const upper = parsePrimary(c)
+    // BETWEEN -> expr >= lower AND expr <= upper
+    return {
+      type: 'binary',
+      op: 'AND',
+      left: { type: 'binary', op: '>=', left, right: lower },
+      right: { type: 'binary', op: '<=', left, right: upper },
+    }
+  }
+
+  // [NOT] IN
+  if (tok.type === 'keyword' && tok.value === 'NOT') {
+    const nextTok = c.peek(1)
+    if (nextTok.type === 'keyword' && nextTok.value === 'IN') {
+      c.consume() // NOT
+      c.consume() // IN
+
+      // Check if it's a subquery or a list of values by peeking ahead
+      // parseSubquery expects to consume the opening paren itself
+      const parenTok = c.current()
+      if (parenTok.type !== 'paren' || parenTok.value !== '(') {
+        throw new Error('Expected ( after IN')
+      }
+      const peekTok = c.peek(1)
+      if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
+        // Subquery - let parseSubquery handle the parens
+        const subquery = c.parseSubquery()
+        return {
+          type: 'unary',
+          op: 'NOT',
+          argument: {
+            type: 'in',
+            expr: left,
+            subquery,
+          },
+        }
+      } else {
+        // Parse list of values - we handle the parens
+        c.consume() // '('
+        /** @type {ExprNode[]} */
+        const values = []
+        while (true) {
+          values.push(parseExpression(c))
+          if (!c.match('comma')) break
+        }
+        c.expect('paren', ')')
+        return {
+          type: 'unary',
+          op: 'NOT',
+          argument: {
+            type: 'in valuelist',
+            expr: left,
+            values,
+          },
+        }
+      }
+    }
+  }
+
+  if (tok.type === 'keyword' && tok.value === 'IN') {
+    c.consume() // IN
+
+    // Check if it's a subquery or a list of values by peeking ahead
+    // parseSubquery expects to consume the opening paren itself
+    const parenTok = c.current()
+    if (parenTok.type !== 'paren' || parenTok.value !== '(') {
+      throw new Error('Expected ( after IN')
+    }
+    const peekTok = c.peek(1)
+    if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
+      // Subquery - let parseSubquery handle the parens
+      const subquery = c.parseSubquery()
+      return {
+        type: 'in',
+        expr: left,
+        subquery,
+      }
+    } else {
+      // Parse list of values - we handle the parens
+      c.consume() // '('
+      /** @type {ExprNode[]} */
+      const values = []
+      while (true) {
+        values.push(parseExpression(c))
+        if (!c.match('comma')) break
+      }
+      c.expect('paren', ')')
+      return {
+        type: 'in valuelist',
+        expr: left,
+        values,
+      }
+    }
+  }
+
+  if (tok.type === 'operator' && isBinaryOp(tok.value)) {
+    c.consume()
+    const right = parsePrimary(c)
+    return {
+      type: 'binary',
+      op: tok.value,
+      left,
+      right,
+    }
+  }
+
+  return left
+}

package/src/parse/expression.js

@@ -1,7 +1,8 @@
 import { isAggregateFunc, isStringFunc } from '../validation.js'
+import { parseComparison } from './comparison.js'
 
 /**
- * @import { BinaryOp, ExprCursor, ExprNode, WhenClause } from '../types.js'
+ * @import { ExprCursor, ExprNode, WhenClause } from '../types.js'
  */
 
 /**
@@ -16,7 +17,7 @@ export function parseExpression(c) {
  * @param {ExprCursor} c
  * @returns {ExprNode}
  */
-function parsePrimary(c) {
+export function parsePrimary(c) {
   const tok = c.current()
 
   if (tok.type === 'paren' && tok.value === '(') {
@@ -253,9 +254,6 @@ function parseNot(c) {
     const nextTok = c.current()
     if (nextTok.type === 'keyword' && nextTok.value === 'EXISTS') {
       c.consume() // EXISTS
-      if (!c.parseSubquery) {
-        throw new Error('Subquery parsing not available in this context')
-      }
       const subquery = c.parseSubquery()
       return {
         type: 'not exists',
@@ -271,217 +269,3 @@ function parseNot(c) {
   }
   return parseComparison(c)
 }
-
-/**
- * @param {ExprCursor} c
- * @returns {ExprNode}
- */
-function parseComparison(c) {
-  const left = parsePrimary(c)
-  const tok = c.current()
-
-  // IS [NOT] NULL
-  if (tok.type === 'keyword' && tok.value === 'IS') {
-    c.consume()
-    const notToken = c.current()
-    if (notToken.type === 'keyword' && notToken.value === 'NOT') {
-      c.consume()
-      c.expect('keyword', 'NULL')
-      return {
-        type: 'unary',
-        op: 'IS NOT NULL',
-        argument: left,
-      }
-    }
-    c.expect('keyword', 'NULL')
-    return {
-      type: 'unary',
-      op: 'IS NULL',
-      argument: left,
-    }
-  }
-
-  // [NOT] LIKE
-  if (tok.type === 'keyword' && tok.value === 'NOT') {
-    const nextTok = c.peek(1)
-    if (nextTok.type === 'keyword' && nextTok.value === 'LIKE') {
-      c.consume() // NOT
-      c.consume() // LIKE
-      const right = parsePrimary(c)
-      return {
-        type: 'unary',
-        op: 'NOT',
-        argument: {
-          type: 'binary',
-          op: 'LIKE',
-          left,
-          right,
-        },
-      }
-    }
-  }
-
-  if (tok.type === 'keyword' && tok.value === 'LIKE') {
-    c.consume()
-    const right = parsePrimary(c)
-    return {
-      type: 'binary',
-      op: 'LIKE',
-      left,
-      right,
-    }
-  }
-
-  // [NOT] BETWEEN - convert to range comparison
-  if (tok.type === 'keyword' && tok.value === 'NOT') {
-    const nextTok = c.peek(1)
-    if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
-      c.consume() // NOT
-      c.consume() // BETWEEN
-      const lower = parsePrimary(c)
-      c.expect('keyword', 'AND')
-      const upper = parsePrimary(c)
-      // NOT BETWEEN -> expr < lower OR expr > upper
-      return {
-        type: 'binary',
-        op: 'OR',
-        left: { type: 'binary', op: '<', left, right: lower },
-        right: { type: 'binary', op: '>', left, right: upper },
-      }
-    }
-  }
-
-  if (tok.type === 'keyword' && tok.value === 'BETWEEN') {
-    c.consume()
-    const lower = parsePrimary(c)
-    c.expect('keyword', 'AND')
-    const upper = parsePrimary(c)
-    // BETWEEN -> expr >= lower AND expr <= upper
-    return {
-      type: 'binary',
-      op: 'AND',
-      left: { type: 'binary', op: '>=', left, right: lower },
-      right: { type: 'binary', op: '<=', left, right: upper },
-    }
-  }
-
-  // [NOT] IN
-  if (tok.type === 'keyword' && tok.value === 'NOT') {
-    const nextTok = c.peek(1)
-    if (nextTok.type === 'keyword' && nextTok.value === 'IN') {
-      c.consume() // NOT
-      c.consume() // IN
-
-      // Check if it's a subquery or a list of values by peeking ahead
-      // parseSubquery expects to consume the opening paren itself
-      const parenTok = c.current()
-      if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-        throw new Error('Expected ( after IN')
-      }
-      const peekTok = c.peek(1)
-      if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
-        // Subquery - let parseSubquery handle the parens
-        if (!c.parseSubquery) {
-          throw new Error('Subquery parsing not available in this context')
-        }
-        const subquery = c.parseSubquery()
-        return {
-          type: 'unary',
-          op: 'NOT',
-          argument: {
-            type: 'in',
-            expr: left,
-            subquery,
-          },
-        }
-      } else {
-        // Parse list of values - we handle the parens
-        c.consume() // '('
-        /** @type {ExprNode[]} */
-        const values = []
-        while (true) {
-          values.push(parseExpression(c))
-          if (!c.match('comma')) break
-        }
-        c.expect('paren', ')')
-        return {
-          type: 'unary',
-          op: 'NOT',
-          argument: {
-            type: 'in valuelist',
-            expr: left,
-            values,
-          },
-        }
-      }
-    }
-  }
-
-  if (tok.type === 'keyword' && tok.value === 'IN') {
-    c.consume() // IN
-
-    // Check if it's a subquery or a list of values by peeking ahead
-    // parseSubquery expects to consume the opening paren itself
-    const parenTok = c.current()
-    if (parenTok.type !== 'paren' || parenTok.value !== '(') {
-      throw new Error('Expected ( after IN')
-    }
-    const peekTok = c.peek(1)
-    if (peekTok.type === 'keyword' && peekTok.value === 'SELECT') {
-      // Subquery - let parseSubquery handle the parens
-      if (!c.parseSubquery) {
-        throw new Error('Subquery parsing not available in this context')
-      }
-      const subquery = c.parseSubquery()
-      return {
-        type: 'in',
-        expr: left,
-        subquery,
-      }
-    } else {
-      // Parse list of values - we handle the parens
-      c.consume() // '('
-      /** @type {ExprNode[]} */
-      const values = []
-      while (true) {
-        values.push(parseExpression(c))
-        if (!c.match('comma')) break
-      }
-      c.expect('paren', ')')
-      return {
-        type: 'in valuelist',
-        expr: left,
-        values,
-      }
-    }
-  }
-
-  if (tok.type === 'operator' && isComparisonOperator(tok.value)) {
-    c.consume()
-    const right = parsePrimary(c)
-    return {
-      type: 'binary',
-      op: tok.value,
-      left,
-      right,
-    }
-  }
-
-  return left
-}
-
-/**
- * @param {string} op
- * @returns {op is BinaryOp}
- */
-function isComparisonOperator(op) {
-  return (
-    op === '=' ||
-    op === '!=' ||
-    op === '<>' ||
-    op === '<' ||
-    op === '>' ||
-    op === '<=' ||
-    op === '>='
-  )
-}

package/src/parse/parse.js

@@ -229,31 +229,22 @@ function parseAggregateItem(state, func) {
   if (cur.type === 'operator' && cur.value === '*') {
     consume(state)
     arg = { kind: 'star' }
-  } else if (cur.type === 'identifier' && cur.value === 'CAST') {
-    // Handle CAST inside aggregate: SUM(CAST(x AS type))
-    expectIdentifier(state) // consume CAST
-    expect(state, 'paren', '(')
-    const cursor = createExprCursor(state)
-    const expr = parseExpression(cursor)
-    expect(state, 'keyword', 'AS')
-    const toType = expectIdentifier(state).value
-    expect(state, 'paren', ')')
-    arg = {
-      kind: 'expression',
-      expr: { type: 'cast', expr, toType },
-    }
   } else {
-    // column name
-    let name = expectIdentifier(state).value
-    // Handle qualified column names like orders.amount
-    if (current(state).type === 'dot') {
-      consume(state) // consume dot
-      const qualifiedPart = expectIdentifier(state)
-      name = `${name}.${qualifiedPart.value}`
+    /** @type {'all' | 'distinct'} */
+    let quantifier = 'all'
+    if (cur.type === 'keyword' && cur.value === 'ALL') {
+      consume(state) // consume ALL
+    } else if (cur.type === 'keyword' && cur.value === 'DISTINCT') {
+      consume(state)
+      quantifier = 'distinct'
     }
+
+    const cursor = createExprCursor(state)
+    const expr = parseExpression(cursor)
     arg = {
       kind: 'expression',
-      expr: { type: 'identifier', name },
+      expr,
+      quantifier,
     }
   }
 

package/src/parse/tokenize.js

@@ -20,6 +20,7 @@ const KEYWORDS = new Set([
   'LIMIT',
   'OFFSET',
   'AS',
+  'ALL',
   'DISTINCT',
   'TRUE',
   'FALSE',

package/src/types.d.ts

@@ -1,10 +1,21 @@
 
+/**
+ * Hints passed to data sources for query optimization.
+ * All hints are optional and "best effort" - sources may ignore them.
+ */
+export interface QueryHints {
+  columns?: string[] // columns needed
+  where?: ExprNode // where clause
+  limit?: number
+  offset?: number
+}
+
 /**
  * Async data source for streaming SQL execution.
  * Provides an async iterator over rows.
  */
 export interface AsyncDataSource {
-  getRows(): AsyncIterable<AsyncRow>
+  getRows(hints?: QueryHints): AsyncIterable<AsyncRow>
 }
 export type AsyncRow = Record<string, AsyncCell>
 export type AsyncCell = () => Promise<SqlPrimitive>
@@ -43,17 +54,9 @@ export interface FromSubquery {
   alias: string
 }
 
-export type BinaryOp =
-  | 'AND'
-  | 'OR'
-  | '='
-  | '!='
-  | '<>'
-  | '<'
-  | '>'
-  | '<='
-  | '>='
-  | 'LIKE'
+export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp
+
+export type ComparisonOp = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>='
 
 export interface LiteralNode {
   type: 'literal'
@@ -154,6 +157,7 @@ export interface AggregateArgStar {
 export interface AggregateArgExpression {
   kind: 'expression'
   expr: ExprNode
+  quantifier: 'all' | 'distinct'
 }
 
 export type AggregateArg = AggregateArgStar | AggregateArgExpression

package/src/validation.js

@@ -1,6 +1,6 @@
 
 /**
- * @import {AggregateFunc, StringFunc} from './types.js'
+ * @import {AggregateFunc, BinaryOp, StringFunc} from './types.js'
  * @param {string} name
  * @returns {name is AggregateFunc}
  */
@@ -15,3 +15,11 @@ export function isAggregateFunc(name) {
 export function isStringFunc(name) {
   return ['UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM', 'REPLACE', 'RANDOM', 'RAND'].includes(name)
 }
+
+/**
+ * @param {string} op
+ * @returns {op is BinaryOp}
+ */
+export function isBinaryOp(op) {
+  return ['=', '!=', '<>', '<', '>', '<=', '>='].includes(op)
+}