squirreling 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "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/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/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

@@ -154,6 +154,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)
+}