@uwdata/mosaic-sql 0.19.0 → 0.20.0

package/src/visit/codegen/duckdb.ts

@@ -0,0 +1,444 @@
+import {
+  SQLNode,
+  ExprNode,
+  AggregateNode,
+  BetweenOpNode,
+  NotBetweenOpNode,
+  BinaryOpNode,
+  CaseNode,
+  WhenNode,
+  CastNode,
+  CollateNode,
+  ColumnParamNode,
+  ColumnRefNode,
+  FragmentNode,
+  FromClauseNode,
+  FunctionNode,
+  InOpNode,
+  IntervalNode,
+  JoinNode,
+  ListNode,
+  LiteralNode,
+  LogicalOpNode,
+  OrderByNode,
+  ParamNode,
+  DescribeQuery,
+  SelectQuery,
+  SetOperation,
+  SampleClauseNode,
+  SelectClauseNode,
+  ScalarSubqueryNode,
+  TableRefNode,
+  UnaryOpNode,
+  UnaryPostfixOpNode,
+  UnnestNode,
+  VerbatimNode,
+  WindowNode,
+  WindowClauseNode,
+  WindowDefNode,
+  WindowFunctionNode,
+  WindowFrameNode,
+  WindowFrameExprNode,
+  WithClauseNode,
+  isNode,
+  isQuery,
+  isTableRef
+} from '../../index.js';
+import { quoteIdentifier } from '../../util/string.js';
+import { literalToSQL } from '../../ast/literal.js';
+import { SQLCodeGenerator } from './sql.js';
+import { CURRENT_ROW, FOLLOWING, PRECEDING, UNBOUNDED } from '../../ast/window-frame.js';
+import { WINDOW_EXTENT_EXPR } from '../../constants.js';
+
+/**
+ * DuckDB SQL dialect visitor for converting AST nodes to DuckDB-compatible SQL.
+ */
+export class DuckDBCodeGenerator extends SQLCodeGenerator {
+  visitAggregate(node: AggregateNode): string {
+    const { name, args, isDistinct, filter, order } = node;
+    const arg = [
+      isDistinct ? 'DISTINCT' : '',
+      args?.length ? this.mapToString(args).join(', ')
+        : name.toLowerCase() === 'count' ? '*'
+        : '',
+      order.length ? `ORDER BY ${this.mapToString(order).join(', ')}` : ''
+    ].filter(x => x).join(' ');
+    const filt = filter ? ` FILTER (WHERE ${this.toString(filter)})` : '';
+    return `${name}(${arg})${filt}`;
+  }
+
+  visitBetween(node: BetweenOpNode): string {
+    return betweenToString(this, node, 'BETWEEN');
+  }
+
+  visitBinary(node: BinaryOpNode): string {
+    const { left, right, op } = node;
+    return `(${this.toString(left)} ${op} ${this.toString(right)})`;
+  }
+
+  visitCase(node: CaseNode): string {
+    const { expr, _when, _else } = node;
+    return 'CASE '
+      + (expr ? `${this.toString(expr)} ` : '')
+      + this.mapToString(_when).join(' ')
+      + (_else ? ` ELSE ${this.toString(_else)}` : '')
+      + ' END';
+  }
+
+  visitCast(node: CastNode): string {
+    const { expr, cast } = node;
+    return `(${this.toString(expr)})::${cast}`;
+  }
+
+  visitCollate(node: CollateNode): string {
+    const { expr, collation } = node;
+    return `${this.toString(expr)} COLLATE ${collation}`;
+  }
+
+  visitColumnParam(node: ColumnParamNode): string {
+    return this.visitColumnRef(node);
+  }
+
+  visitColumnRef(node: ColumnRefNode): string {
+    const { column, table } = node;
+    const tref = table ? `${this.toString(table)}.` : '';
+    const id = column === '*' ? '*' : quoteIdentifier(column);
+    return `${tref}${id}`;
+  }
+
+  visitDescribeQuery(node: DescribeQuery): string {
+    const { query } = node;
+    return `DESC ${this.toString(query)}`;
+  }
+
+  visitExpression(node: ExprNode): string {
+    // This method might not be used in practice, but needs to exist for the interface
+    // If we reach here, it might be an error or a generic fallback
+    throw new Error(`Unexpected EXPRESSION node type. Node: ${JSON.stringify(node)}`);
+  }
+
+  visitFragment(node: FragmentNode): string {
+    const { spans } = node;
+    return spans.map((span: string | SQLNode) => {
+      return typeof span === 'string' ? span : this.toString(span);
+    }).join('');
+  }
+
+  visitFromClause(node: FromClauseNode): string {
+    const { expr, alias, sample } = node;
+    const ref = isQuery(expr) ? `(${this.toString(expr)})` : `${this.toString(expr)}`;
+    const from = alias && !(isTableRef(expr) && expr.table?.join('.') === alias)
+      ? `${ref} AS ${quoteIdentifier(alias)}`
+      : `${ref}`;
+    return `${from}${sample ? ` TABLESAMPLE ${this.toString(sample)}` : ''}`;
+  }
+
+  visitFunction(node: FunctionNode): string {
+    const { name, args } = node;
+    return `${name}(${this.mapToString(args).join(', ')})`;
+  }
+
+  visitIn(node: InOpNode): string {
+    const { expr, values } = node;
+    return `(${this.toString(expr)} IN (${this.mapToString(values).join(', ')}))`;
+  }
+
+  visitInterval(node: IntervalNode): string {
+    const { steps, name } = node;
+    return `INTERVAL ${steps} ${name}`;
+  }
+
+  visitJoinClause(node: JoinNode): string {
+    const { left, right, joinVariant, joinType, condition, using, sample } = node;
+    const variant = joinVariant === 'REGULAR' ? '' : `${joinVariant} `;
+    let type = '';
+    let cond = '';
+
+    if (joinVariant !== 'CROSS') {
+      type = joinType !== 'INNER' ? `${joinType} ` : '';
+      cond = condition ? ` ON ${this.toString(condition)}`
+        : using ? ` USING (${this.mapToString(using).join(', ')})`
+        : '';
+    }
+    const samp = sample ? ` USING SAMPLE ${this.toString(sample)}` : '';
+    return `${this.toString(left)} ${variant}${type}JOIN ${this.toString(right)}${cond}${samp}`;
+  }
+
+  visitList(node: ListNode): string {
+    const { values } = node;
+    return `[${this.mapToString(values).join(', ')}]`;
+  }
+
+  visitLiteral(node: LiteralNode): string {
+    const { value } = node;
+    return literalToSQL(value);
+  }
+
+  visitLogicalOperator(node: LogicalOpNode<ExprNode>): string {
+    const { clauses, op } = node;
+    const c = this.mapToString(clauses);
+    return c.length === 0 ? ''
+      : c.length === 1 ? `${c[0]}`
+      : `(${c.join(` ${op} `)})`;
+  }
+
+  visitNotBetween(node: NotBetweenOpNode): string {
+    return betweenToString(this, node, 'NOT BETWEEN');
+  }
+
+  visitOrderBy(node: OrderByNode): string {
+    const { expr, desc, nullsFirst } = node;
+    const dir = desc ? ' DESC'
+      : desc === false ? ' ASC'
+      : '';
+    const nf = nullsFirst ? ' NULLS FIRST'
+      : nullsFirst === false ? ' NULLS LAST'
+      : '';
+    return `${this.toString(expr)}${dir}${nf}`;
+  }
+
+  visitParam(node: ParamNode): string {
+    const { param } = node;
+    // Get the current value from the parameter and format it as a literal
+    return literalToSQL(param.value);
+  }
+
+  visitSampleClause(node: SampleClauseNode): string {
+    const { size, perc, method, seed } = node;
+    const m = method ? `${method} ` : '';
+    const s = seed != null ? ` REPEATABLE (${seed})` : '';
+    return `${m}(${size}${perc ? '%' : ' ROWS'})${s}`;
+  }
+
+  visitScalarSubquery(node: ScalarSubqueryNode): string {
+    return `(${this.toString(node.subquery)})`;
+  }
+
+  visitSelectClause(node: SelectClauseNode): string {
+    const { expr, alias } = node;
+
+    return !alias || isColumnRefFor(expr, alias)
+      ? this.toString(expr)
+      : `${this.toString(expr)} AS ${quoteIdentifier(alias)}`;
+  }
+
+  visitSelectQuery(node: SelectQuery): string {
+    const {
+      _with, _select, _distinct, _from, _sample, _where,
+      _groupby, _having, _window, _qualify, _orderby,
+      _limitPerc, _limit, _offset
+    } = node;
+
+    const sql = [];
+
+    // WITH
+    if (_with.length) {
+      sql.push(`WITH ${this.mapToString(_with).join(', ')}`);
+    }
+
+    // SELECT
+    sql.push(`SELECT${_distinct ? ' DISTINCT' : ''} ${this.mapToString(_select).join(', ')}`);
+
+    // FROM
+    if (_from.length) {
+      sql.push(`FROM ${this.mapToString(_from).join(', ')}`);
+    }
+
+    // SAMPLE
+    if (_sample) {
+      sql.push(`USING SAMPLE ${this.toString(_sample)}`);
+    }
+
+    // WHERE
+    if (_where.length) {
+      const clauses = this.mapToString(_where).filter(x => x).join(' AND ');
+      if (clauses) sql.push(`WHERE ${clauses}`);
+    }
+
+    // GROUP BY
+    if (_groupby.length) {
+      sql.push(`GROUP BY ${this.mapToString(_groupby).join(', ')}`);
+    }
+
+    // HAVING
+    if (_having.length) {
+      const clauses = this.mapToString(_having).filter(x => x).join(' AND ');
+      if (clauses) sql.push(`HAVING ${clauses}`);
+    }
+
+    // WINDOW
+    if (_window.length) {
+      sql.push(`WINDOW ${this.mapToString(_window).join(', ')}`);
+    }
+
+    // QUALIFY
+    if (_qualify.length) {
+      const clauses = this.mapToString(_qualify).filter(x => x).join(' AND ');
+      if (clauses) sql.push(`QUALIFY ${clauses}`);
+    }
+
+    // ORDER BY
+    if (_orderby.length) {
+      sql.push(`ORDER BY ${this.mapToString(_orderby).join(', ')}`);
+    }
+
+    // LIMIT
+    if (_limit) {
+      sql.push(`LIMIT ${this.toString(_limit)}${_limitPerc ? '%' : ''}`);
+    }
+
+    // OFFSET
+    if (_offset != null) {
+      sql.push(`OFFSET ${this.toString(_offset)}`);
+    }
+
+    return sql.join(' ');
+  }
+
+  visitSetOperation(node: SetOperation): string {
+    const { op, queries, _with, _orderby, _limitPerc, _limit, _offset } = node;
+    const sql = [];
+
+    // WITH
+    if (_with.length) sql.push(`WITH ${this.mapToString(_with).join(', ')}`);
+
+    // SUBQUERIES
+    sql.push(queries.join(` ${op} `));
+
+    // ORDER BY
+    if (_orderby.length) sql.push(`ORDER BY ${this.mapToString(_orderby).join(', ')}`);
+
+    // LIMIT
+    if (_limit) sql.push(`LIMIT ${this.toString(_limit)}${_limitPerc ? '%' : ''}`);
+
+    // OFFSET
+    if (_offset) sql.push(`OFFSET ${this.toString(_offset)}`);
+
+    return sql.join(' ');
+  }
+
+  visitTableRef(node: TableRefNode): string {
+    const { table } = node;
+    return table.map((t: string) => quoteIdentifier(t)).join('.');
+  }
+
+  visitUnary(node: UnaryOpNode): string {
+    const { expr, op } = node;
+    return `(${op} ${this.toString(expr)})`;
+  }
+
+  visitUnaryPostfix(node: UnaryPostfixOpNode): string {
+    const { expr, op } = node;
+    return `(${this.toString(expr)} ${op})`;
+  }
+
+  visitUnnest(node: UnnestNode): string {
+    const { expr, recursive, maxDepth } = node;
+    const args = [this.toString(expr)];
+
+    if (recursive) {
+      args.push('recursive := true');
+    }
+    if (maxDepth != null && maxDepth > 0) {
+      args.push(`max_depth := ${maxDepth}`);
+    }
+
+    return `UNNEST(${args.join(', ')})`;
+  }
+
+  visitVerbatim(node: VerbatimNode): string {
+    const { value } = node;
+    return value;
+  }
+
+  visitWhen(node: WhenNode): string {
+    const { when, then } = node;
+    return `WHEN ${this.toString(when)} THEN ${this.toString(then)}`;
+  }
+
+  visitWindow(node: WindowNode): string {
+    const { func, def } = node;
+    return `${this.toString(func)} OVER ${this.toString(def)}`;
+  }
+
+  visitWindowClause(node: WindowClauseNode): string {
+    const { name, def } = node;
+    return `${quoteIdentifier(name)} AS ${this.toString(def)}`;
+  }
+
+  visitWindowDef(node: WindowDefNode): string {
+    const { name, partition, order, framedef } = node;
+    const base = name && quoteIdentifier(name);
+    const def = [
+      base,
+      partition?.length && `PARTITION BY ${this.mapToString(partition).join(', ')}`,
+      order?.length && `ORDER BY ${this.mapToString(order).join(', ')}`,
+      framedef && this.toString(framedef)
+    ].filter(x => x);
+    return base && def.length < 2 ? base : `(${def.join(' ')})`;
+  }
+
+  visitWindowExtentExpr(node: WindowFrameExprNode): string {
+    const { scope, expr } = node;
+    return scope === CURRENT_ROW
+      ? scope
+      : `${isNode(expr) ? this.toString(expr) : (expr ?? UNBOUNDED)} ${scope}`;
+  }
+
+  visitWindowFrame(node: WindowFrameNode): string {
+    const { frameType, exclude, extent } = node;
+    const [prev, next] = isNode(extent)
+      ? extent.value as [unknown, unknown]
+      : extent;
+    const a = formatFrameExpr(this, prev, PRECEDING);
+    const b = formatFrameExpr(this, next, FOLLOWING);
+    return `${frameType} BETWEEN ${a} AND ${b}${exclude ? ` ${exclude}` : ''}`;
+  }
+
+  visitWindowFunction(node: WindowFunctionNode): string {
+    const { name, args, ignoreNulls, order } = node;
+    const arg = [
+      this.mapToString(args).join(', '),
+      order.length ? `ORDER BY ${this.mapToString(order).join(', ')}` : '',
+      ignoreNulls ? 'IGNORE NULLS' : ''
+    ].filter(x => x).join(' ');
+    return `${name}(${arg})`;
+  }
+
+  visitWithClause(node: WithClauseNode): string {
+    const { name, query, materialized } = node;
+    const mat = materialized === true ? 'MATERIALIZED '
+      : materialized === false ? 'NOT MATERIALIZED '
+      : '';
+    return `${quoteIdentifier(name)} AS ${mat}(${this.toString(query)})`;
+  }
+}
+
+function isColumnRefFor(expr: unknown, name: string): expr is ColumnRefNode {
+  return expr instanceof ColumnRefNode
+    && expr.table == null
+    && expr.column === name;
+}
+
+function betweenToString(
+  visitor: SQLCodeGenerator,
+  node: BetweenOpNode | NotBetweenOpNode,
+  op: string
+) {
+  const { extent, expr } = node;
+  if (!extent) return '';
+  const [a, b] = visitor.mapToString(extent);
+  return `(${visitor.toString(expr)} ${op} ${a} AND ${b})`;
+}
+
+function formatFrameExpr(visitor: SQLCodeGenerator, value: unknown, scope: string) {
+  const x = isNode(value) ? visitor.toString(value) : value;
+  return isNode(value) && value.type === WINDOW_EXTENT_EXPR ? x
+    : x != null && typeof x !== 'number' ? `${x} ${scope}`
+    : x === 0 ? CURRENT_ROW
+    : !(x && Number.isFinite(x)) ? `${UNBOUNDED} ${scope}`
+    : `${Math.abs(x)} ${scope}`;
+}
+
+// Create a default DuckDB visitor instance for convenience
+export const duckDBCodeGenerator = new DuckDBCodeGenerator();

package/src/visit/codegen/sql.ts

@@ -0,0 +1,213 @@
+import type {
+  SQLNode,
+  ExprNode,
+  AggregateNode,
+  BetweenOpNode,
+  NotBetweenOpNode,
+  BinaryOpNode,
+  CaseNode,
+  WhenNode,
+  CastNode,
+  CollateNode,
+  ColumnParamNode,
+  ColumnRefNode,
+  FragmentNode,
+  FromClauseNode,
+  FunctionNode,
+  InOpNode,
+  IntervalNode,
+  JoinNode,
+  ListNode,
+  LiteralNode,
+  LogicalOpNode,
+  OrderByNode,
+  ParamNode,
+  DescribeQuery,
+  SelectQuery,
+  SetOperation,
+  SampleClauseNode,
+  SelectClauseNode,
+  ScalarSubqueryNode,
+  TableRefNode,
+  UnaryOpNode,
+  UnaryPostfixOpNode,
+  UnnestNode,
+  VerbatimNode,
+  WindowNode,
+  WindowClauseNode,
+  WindowDefNode,
+  WindowFunctionNode,
+  WindowFrameNode,
+  WindowFrameExprNode,
+  WithClauseNode
+} from '../../index.js';
+import {
+  AGGREGATE,
+  BETWEEN_OPERATOR,
+  BINARY_OPERATOR,
+  CASE,
+  CAST,
+  COLLATE,
+  COLUMN_PARAM,
+  COLUMN_REF,
+  DESCRIBE_QUERY,
+  EXPRESSION,
+  FRAGMENT,
+  FROM_CLAUSE,
+  FUNCTION,
+  IN_OPERATOR,
+  INTERVAL,
+  JOIN_CLAUSE,
+  LIST,
+  LITERAL,
+  LOGICAL_OPERATOR,
+  NOT_BETWEEN_OPERATOR,
+  ORDER_BY,
+  PARAM,
+  SAMPLE_CLAUSE,
+  SCALAR_SUBQUERY,
+  SELECT_CLAUSE,
+  SELECT_QUERY,
+  SET_OPERATION,
+  TABLE_REF,
+  UNARY_OPERATOR,
+  UNARY_POSTFIX_OPERATOR,
+  UNNEST,
+  VERBATIM,
+  WHEN,
+  WINDOW,
+  WINDOW_CLAUSE,
+  WINDOW_DEF,
+  WINDOW_EXTENT_EXPR,
+  WINDOW_FRAME,
+  WINDOW_FUNCTION,
+  WITH_CLAUSE
+} from '../../constants.js';
+
+/**
+ * Abstract base class for SQL code generation visitors.
+ */
+export abstract class SQLCodeGenerator {
+  /**
+   * Convert a SQL AST node to a string using this visitor.
+   * @param node The SQL AST node to convert.
+   * @returns The SQL string representation.
+   */
+  toString(node: SQLNode): string {
+    if (!node) {
+      throw new Error('Node is null or undefined');
+    }
+    if (typeof node.type !== 'string') {
+      throw new Error(`Node type is not a string: ${typeof node.type}, value: ${node.type}`);
+    }
+    if (node.type === 'CUSTOM') {
+      // custom node types provide their own handling
+      // pass the visitor through to apply to child nodes
+      return node.toString(this);
+    }
+    const method = this.getVisitMethod(node.type);
+    if (typeof method === 'function') {
+      // @ts-expect-error: dispatch based on node type
+      return method.call(this, node);
+    }
+    throw new Error(`No visitor method for node type: '${node.type}'`);
+  }
+
+  protected getVisitMethod(nodeType: string) {
+    switch (nodeType) {
+      case AGGREGATE: return this.visitAggregate;
+      case BETWEEN_OPERATOR: return this.visitBetween;
+      case BINARY_OPERATOR: return this.visitBinary;
+      case CASE: return this.visitCase;
+      case CAST: return this.visitCast;
+      case COLLATE: return this.visitCollate;
+      case COLUMN_PARAM: return this.visitColumnParam;
+      case COLUMN_REF: return this.visitColumnRef;
+      case DESCRIBE_QUERY: return this.visitDescribeQuery;
+      case EXPRESSION: return this.visitExpression;
+      case FRAGMENT: return this.visitFragment;
+      case FROM_CLAUSE: return this.visitFromClause;
+      case FUNCTION: return this.visitFunction;
+      case IN_OPERATOR: return this.visitIn;
+      case INTERVAL: return this.visitInterval;
+      case JOIN_CLAUSE: return this.visitJoinClause;
+      case LIST: return this.visitList;
+      case LITERAL: return this.visitLiteral;
+      case LOGICAL_OPERATOR: return this.visitLogicalOperator;
+      case NOT_BETWEEN_OPERATOR: return this.visitNotBetween;
+      case ORDER_BY: return this.visitOrderBy;
+      case PARAM: return this.visitParam;
+      case SAMPLE_CLAUSE: return this.visitSampleClause;
+      case SCALAR_SUBQUERY: return this.visitScalarSubquery;
+      case SELECT_CLAUSE: return this.visitSelectClause;
+      case SELECT_QUERY: return this.visitSelectQuery;
+      case SET_OPERATION: return this.visitSetOperation;
+      case TABLE_REF: return this.visitTableRef;
+      case UNARY_OPERATOR: return this.visitUnary;
+      case UNARY_POSTFIX_OPERATOR: return this.visitUnaryPostfix;
+      case UNNEST: return this.visitUnnest;
+      case VERBATIM: return this.visitVerbatim;
+      case WHEN: return this.visitWhen;
+      case WINDOW: return this.visitWindow;
+      case WINDOW_CLAUSE: return this.visitWindowClause;
+      case WINDOW_DEF: return this.visitWindowDef;
+      case WINDOW_EXTENT_EXPR: return this.visitWindowExtentExpr;
+      case WINDOW_FRAME: return this.visitWindowFrame;
+      case WINDOW_FUNCTION: return this.visitWindowFunction;
+      case WITH_CLAUSE: return this.visitWithClause;
+      default:
+        throw new Error(`Unknown node type: '${nodeType}'`);
+    }
+  }
+
+  /**
+   * Helper method to convert child nodes to strings.
+   * @param nodes Array of child nodes.
+   * @returns Array of SQL strings.
+   */
+  mapToString(nodes: SQLNode[]): string[] {
+    return nodes.map(node => this.toString(node));
+  }
+
+  // Abstract methods that must be implemented by concrete visitors
+  abstract visitAggregate(node: AggregateNode): string;
+  abstract visitBetween(node: BetweenOpNode): string;
+  abstract visitBinary(node: BinaryOpNode): string;
+  abstract visitCase(node: CaseNode): string;
+  abstract visitCast(node: CastNode): string;
+  abstract visitCollate(node: CollateNode): string;
+  abstract visitColumnParam(node: ColumnParamNode): string;
+  abstract visitColumnRef(node: ColumnRefNode): string;
+  abstract visitDescribeQuery(node: DescribeQuery): string;
+  abstract visitExpression(node: ExprNode): string;
+  abstract visitFragment(node: FragmentNode): string;
+  abstract visitFromClause(node: FromClauseNode): string;
+  abstract visitFunction(node: FunctionNode): string;
+  abstract visitIn(node: InOpNode): string;
+  abstract visitInterval(node: IntervalNode): string;
+  abstract visitJoinClause(node: JoinNode): string;
+  abstract visitList(node: ListNode): string;
+  abstract visitLiteral(node: LiteralNode): string;
+  abstract visitLogicalOperator(node: LogicalOpNode<ExprNode>): string;
+  abstract visitNotBetween(node: NotBetweenOpNode): string;
+  abstract visitOrderBy(node: OrderByNode): string;
+  abstract visitParam(node: ParamNode): string;
+  abstract visitSampleClause(node: SampleClauseNode): string;
+  abstract visitScalarSubquery(node: ScalarSubqueryNode): string;
+  abstract visitSelectClause(node: SelectClauseNode): string;
+  abstract visitSelectQuery(node: SelectQuery): string;
+  abstract visitSetOperation(node: SetOperation): string;
+  abstract visitTableRef(node: TableRefNode): string;
+  abstract visitUnary(node: UnaryOpNode): string;
+  abstract visitUnaryPostfix(node: UnaryPostfixOpNode): string;
+  abstract visitUnnest(node: UnnestNode): string;
+  abstract visitVerbatim(node: VerbatimNode): string;
+  abstract visitWhen(node: WhenNode): string;
+  abstract visitWindow(node: WindowNode): string;
+  abstract visitWindowClause(node: WindowClauseNode): string;
+  abstract visitWindowDef(node: WindowDefNode): string;
+  abstract visitWindowExtentExpr(node: WindowFrameExprNode): string;
+  abstract visitWindowFrame(node: WindowFrameNode): string;
+  abstract visitWindowFunction(node: WindowFunctionNode): string;
+  abstract visitWithClause(node: WithClauseNode): string;
+}

package/src/visit/recurse.ts

@@ -13,6 +13,7 @@ import {
   FROM_CLAUSE,
   FUNCTION,
   IN_OPERATOR,
+  JOIN_CLAUSE,
   LOGICAL_OPERATOR,
   NOT_BETWEEN_OPERATOR,
   ORDER_BY,
@@ -49,6 +50,7 @@ export const recurse: Record<string, string[]> = {
   [FROM_CLAUSE]: ['expr'],
   [FUNCTION]: ['args'],
   [IN_OPERATOR]: ['expr', 'values'],
+  [JOIN_CLAUSE]: ['left', 'right', 'on', 'using', 'sample'],
   [LOGICAL_OPERATOR]: ['clauses'],
   [NOT_BETWEEN_OPERATOR]: ['expr', 'extent'],
   [ORDER_BY]: ['expr'],