squirreling 0.4.0 → 0.4.2

package/src/parse/parse.js

@@ -3,7 +3,7 @@ import { parseExpression } from './expression.js'
 import { isAggregateFunc } from '../validation.js'
 
 /**
- * @import { AggregateColumn, AggregateArg, AggregateFunc, ExprCursor, ExprNode, FromSubquery, JoinClause, JoinType, OrderByItem, ParserState, SelectStatement, SelectColumn, Token, TokenType } from '../types.js'
+ * @import { AggregateColumn, AggregateArg, AggregateFunc, ExprCursor, ExprNode, FromSubquery, FromTable, JoinClause, JoinType, OrderByItem, ParserState, SelectStatement, SelectColumn, Token, TokenType } from '../types.js'
  */
 
 // Keywords that cannot be used as implicit aliases after a column
@@ -17,6 +17,23 @@ const RESERVED_AFTER_COLUMN = new Set([
   'OFFSET',
 ])
 
+// Keywords that cannot be used as table aliases
+const RESERVED_AFTER_TABLE = new Set([
+  'WHERE',
+  'GROUP',
+  'HAVING',
+  'ORDER',
+  'LIMIT',
+  'OFFSET',
+  'JOIN',
+  'INNER',
+  'LEFT',
+  'RIGHT',
+  'FULL',
+  'CROSS',
+  'ON',
+])
+
 /**
  * @param {string} query
  * @returns {SelectStatement}
@@ -219,17 +236,24 @@ function parseAggregateItem(state, func) {
     const cursor = createExprCursor(state)
     const expr = parseExpression(cursor)
     expect(state, 'keyword', 'AS')
-    const typeTok = expectIdentifier(state)
+    const toType = expectIdentifier(state).value
     expect(state, 'paren', ')')
     arg = {
       kind: 'expression',
-      expr: { type: 'cast', expr, toType: typeTok.value },
+      expr: { type: 'cast', expr, toType },
     }
   } else {
-    const colTok = expectIdentifier(state)
+    // 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}`
+    }
     arg = {
       kind: 'expression',
-      expr: { type: 'identifier', name: colTok.value },
+      expr: { type: 'identifier', name },
     }
   }
 
@@ -240,6 +264,25 @@ function parseAggregateItem(state, func) {
   return { kind: 'aggregate', func, arg, alias }
 }
 
+/**
+ * Parses an optional table alias (e.g., "FROM users u" or "FROM users AS u")
+ * @param {ParserState} state
+ * @returns {string | undefined}
+ */
+function parseTableAlias(state) {
+  // Check for explicit AS keyword
+  if (match(state, 'keyword', 'AS')) {
+    const aliasTok = expectIdentifier(state)
+    return aliasTok.value
+  }
+  // Check for implicit alias (identifier not in reserved list)
+  const maybeAlias = current(state)
+  if (maybeAlias.type === 'identifier' && !RESERVED_AFTER_TABLE.has(maybeAlias.value.toUpperCase())) {
+    consume(state)
+    return maybeAlias.value
+  }
+}
+
 /**
  * @param {ParserState} state
  * @returns {string | undefined}
@@ -322,9 +365,9 @@ function parseJoins(state) {
       break
     }
 
-    // Parse table name
-    const tableTok = expectIdentifier(state)
-    const tableName = tableTok.value
+    // Parse table name and optional alias
+    const tableName = expectIdentifier(state).value
+    const tableAlias = parseTableAlias(state)
 
     // Parse ON condition
     expect(state, 'keyword', 'ON')
@@ -332,8 +375,9 @@ function parseJoins(state) {
     const condition = parseExpression(cursor)
 
     joins.push({
-      type: joinType,
+      joinType,
       table: tableName,
+      alias: tableAlias,
       on: condition,
     })
   }
@@ -351,12 +395,8 @@ function parseSubquery(state) {
   const query = parseSelectInternal(state)
   expect(state, 'paren', ')')
   expect(state, 'keyword', 'AS')
-  const aliasTok = expectIdentifier(state)
-  return {
-    kind: 'subquery',
-    query,
-    alias: aliasTok.value,
-  }
+  const alias = expectIdentifier(state).value
+  return { kind: 'subquery', query, alias }
 }
 
 /**
@@ -376,6 +416,7 @@ function parseSelectInternal(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 === '(') {
@@ -383,7 +424,9 @@ function parseSelectInternal(state) {
     from = parseSubquery(state)
   } else {
     // Simple table name: SELECT * FROM users
-    from = expectIdentifier(state).value
+    const table = expectIdentifier(state).value
+    const alias = parseTableAlias(state)
+    from = { kind: 'table', table, alias }
   }
 
   // Parse JOIN clauses

package/src/types.d.ts

@@ -21,7 +21,7 @@ export type SqlPrimitive = string | number | bigint | boolean | null
 export interface SelectStatement {
   distinct: boolean
   columns: SelectColumn[]
-  from: string | FromSubquery
+  from: FromTable | FromSubquery
   joins: JoinClause[]
   where?: ExprNode
   groupBy: ExprNode[]
@@ -31,6 +31,12 @@ export interface SelectStatement {
   offset?: number
 }
 
+export interface FromTable {
+  kind: 'table'
+  table: string
+  alias?: string
+}
+
 export interface FromSubquery {
   kind: 'subquery'
   query: SelectStatement
@@ -84,21 +90,14 @@ export interface CastNode {
   toType: string
 }
 
-export interface BetweenNode {
-  type: 'between' | 'not between'
-  expr: ExprNode
-  lower: ExprNode
-  upper: ExprNode
-}
-
 export interface InSubqueryNode {
-  type: 'in' | 'not in'
+  type: 'in'
   expr: ExprNode
   subquery: SelectStatement
 }
 
 export interface InValuesNode {
-  type: 'in valuelist' | 'not in valuelist'
+  type: 'in valuelist'
   expr: ExprNode
   values: ExprNode[]
 }
@@ -132,7 +131,6 @@ export type ExprNode =
   | BinaryNode
   | FunctionNode
   | CastNode
-  | BetweenNode
   | InSubqueryNode
   | InValuesNode
   | ExistsNode
@@ -184,8 +182,9 @@ export interface OrderByItem {
 export type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS'
 
 export interface JoinClause {
-  type: JoinType
+  joinType: JoinType
   table: string
+  alias?: string
   on?: ExprNode
 }
 

package/src/validation.js

@@ -13,5 +13,5 @@ export function isAggregateFunc(name) {
  * @returns {name is StringFunc}
  */
 export function isStringFunc(name) {
-  return ['UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM', 'REPLACE'].includes(name)
+  return ['UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM', 'REPLACE', 'RANDOM', 'RAND'].includes(name)
 }