@uwdata/mosaic-sql 0.18.0 → 0.20.0

package/src/functions/join.ts

@@ -0,0 +1,101 @@
+import { ColumnRefNode } from '../ast/column-ref.js';
+import { FromNode } from '../ast/from.js';
+import { JoinNode, type JoinType, type JoinVariant } from '../ast/join.js';
+import { ExprNode } from '../ast/node.js';
+import { asNode, asTableRef } from '../util/ast.js';
+
+type TableArg = string | string[] | FromNode;
+
+/** Options for a JOIN operation. */
+interface JoinOptions {
+  /** The join type (INNER, LEFT, RIGHT, FULL, SEMI, ANTI). */
+  type?: JoinType;
+  /**
+   * The join condition as a boolean expression.
+   * If specified, the *using* option must not be specified.
+   */
+  on?: ExprNode;
+  /**
+   * The join condition as an array of columns to match.
+   * The column names must exist in both tables.
+   * If specified, the *on* option must not be specified.
+   */
+  using?: (string | ColumnRefNode)[];
+}
+
+function tableRef(x: TableArg) {
+  return x instanceof FromNode ? x : asTableRef(x)!;
+}
+
+function makeJoin(
+  left: TableArg,
+  right: TableArg,
+  variant?: JoinVariant,
+  options: JoinOptions = {}
+) {
+  if (options.on && options.using) {
+    throw new Error('Only one join condition (on or using) can be applied.');
+  }
+  return new JoinNode(
+    tableRef(left),
+    tableRef(right),
+    variant,
+    options.type,
+    options.on,
+    options.using?.map(c => asNode(c) as ColumnRefNode)
+  );
+}
+
+/**
+ * Create a new cross (cartesian product) join.
+ * @param left The left table to join.
+ * @param right The right table to join.
+ */
+export function cross_join(left: TableArg, right: TableArg) {
+  return makeJoin(left, right, 'CROSS');
+}
+
+/**
+ * Create a new POSITIONAL join.
+ * @param left The left table to join.
+ * @param right The right table to join.
+ */
+export function positional_join(left: TableArg, right: TableArg) {
+  return makeJoin(left, right, 'POSITIONAL');
+}
+
+/**
+ * Create a new join.
+ * @param left The left table to join.
+ * @param right The right table to join.
+ * @param options The join options.
+ */
+export function join(
+  left: TableArg,
+  right: TableArg,
+  options?: JoinOptions
+) {
+  return makeJoin(
+    left,
+    right,
+    options?.on || options?.using ? 'REGULAR' : 'NATURAL',
+    options
+  );
+}
+
+/**
+ * Create a new ASOF join.
+ * @param left The left table to join.
+ * @param right The right table to join.
+ * @param options The join options.
+ */
+export function asof_join(
+  left: TableArg,
+  right: TableArg,
+  options: JoinOptions
+) {
+  if (!(options.on || options.using)) {
+    throw new Error('ASOF join requires a join condition.');
+  }
+  return makeJoin(left, right, 'ASOF', options);
+}

package/src/functions/list.ts

@@ -0,0 +1,63 @@
+import type { ExprValue } from "../types.js";
+import { asLiteral, asNode } from "../util/ast.js";
+import { argsList, fn } from "../util/function.js";
+import { ListNode } from "../ast/list.js";
+
+/**
+ * Create a List containing the argument values.
+ * @param values
+ */
+export function list(values: ExprValue[]) {
+  return new ListNode(argsList(values).map(asLiteral));
+}
+
+/**
+ * Convert a single value or an array of values to either a ListNode if the input
+ * is an array, or a single ExprNode if it is a single value. A single string will
+ * be interpreted as a column reference.
+ * @param values
+ */
+function asList(values: ExprValue | ExprValue[]) {
+  return Array.isArray(values) ? list(values) : asNode(values);
+}
+
+/**
+ * Function that returns true if the list contains the element,
+ * false otherwise. If the first argument is a string, it is
+ * interpreted as a column reference, otherwise it is coerced
+ * to a list.
+ * @param list1
+ * @param element
+ */
+export function listContains(
+  list1: ExprValue | ExprValue[],
+  element: ExprValue,
+) {
+  return fn("list_contains", asList(list1), asLiteral(element));
+}
+
+/**
+ * Function that returns true if all elements of list2 exist in list1,
+ * false otherwise.
+ * @param list1
+ * @param list2
+ */
+export function listHasAll(
+  list1: ExprValue | ExprValue[],
+  list2: ExprValue | ExprValue[],
+) {
+  return fn("list_has_all", asList(list1), asList(list2));
+}
+
+/**
+ * Function that returns true if any elements exist in both lists,
+ * false otherwise.
+ * @param list1
+ * @param list2
+ */
+export function listHasAny(
+  list1: ExprValue | ExprValue[],
+  list2: ExprValue | ExprValue[],
+) {
+  return fn("list_has_any", asList(list1), asList(list2));
+}

package/src/functions/unnest.ts

@@ -0,0 +1,13 @@
+import type { ExprValue } from "../types.js";
+import { asNode } from "../util/ast.js";
+import { UnnestNode } from "../ast/unnest.js";
+
+/**
+ * Create an Unnest Node to flatten nested structures, either structs or lists.
+ * @param value
+ * @param recursive
+ * @param maxDepth
+ */
+export function unnest(value: ExprValue, recursive = false, maxDepth = 0) {
+  return new UnnestNode(asNode(value), recursive, maxDepth);
+}

package/src/index.ts

@@ -1,3 +1,6 @@
+// Initialize default visitor
+import './init.js';
+
 export { AggregateNode, aggregateNames, isAggregateFunction } from './ast/aggregate.js';
 export { BetweenOpNode, NotBetweenOpNode } from './ast/between-op.js'
 export { BinaryOpNode } from './ast/binary-op.js';
@@ -11,8 +14,10 @@ export { FromClauseNode } from './ast/from.js';
 export { FunctionNode } from './ast/function.js';
 export { InOpNode } from './ast/in-op.js';
 export { IntervalNode } from './ast/interval.js';
+export { JoinNode, type JoinType, type JoinVariant } from './ast/join.js';
+export { ListNode } from './ast/list.js';
 export { LiteralNode } from './ast/literal.js';
-export { AndNode, OrNode } from './ast/logical-op.js';
+export { LogicalOpNode, AndNode, OrNode } from './ast/logical-op.js';
 export { SQLNode, ExprNode, isNode } from './ast/node.js';
 export { OrderByNode } from './ast/order-by.js';
 export { ParamNode } from './ast/param.js';
@@ -22,6 +27,7 @@ export { ScalarSubqueryNode } from './ast/subquery.js';
 export { SelectClauseNode } from './ast/select.js';
 export { TableRefNode, isTableRef } from './ast/table-ref.js';
 export { UnaryOpNode, UnaryPostfixOpNode } from './ast/unary-op.js';
+export { UnnestNode } from './ast/unnest.js';
 export { VerbatimNode } from './ast/verbatim.js';
 export { WindowClauseNode, WindowDefNode, WindowFunctionNode, WindowNode } from './ast/window.js';
 export { WindowFrameNode, WindowFrameExprNode, type FrameExclude, type FrameExtent, type FrameScope, type FrameType, type FrameValue } from './ast/window-frame.js';
@@ -34,7 +40,10 @@ export { collate } from './functions/collate.js';
 export { column } from './functions/column.js';
 export { cte } from './functions/cte.js';
 export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms } from './functions/datetime.js';
+export { from } from './functions/from.js';
 export { days, hours, interval, microseconds, minutes, milliseconds, months, seconds, years } from './functions/interval.js';
+export { asof_join, cross_join, join, positional_join } from './functions/join.js';
+export { list, listContains, listHasAll, listHasAny } from './functions/list.js';
 export { literal, verbatim } from './functions/literal.js';
 export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from './functions/numeric.js';
 export { and, or, not, isNull, isNotNull, bitNot, bitAnd, bitOr, bitLeft, bitRight, add, sub, mul, div, idiv, mod, pow, eq, neq, lt, gt, lte, gte, isDistinct, isNotDistinct, isBetween, isNotBetween, isIn } from './functions/operators.js';
@@ -42,6 +51,7 @@ export { asc, desc } from './functions/order-by.js';
 export { geojson, x, y, centroid, centroidX, centroidY } from './functions/spatial.js';
 export { sql } from './functions/sql-template-tag.js';
 export { regexp_matches, contains, prefix, suffix, lower, upper, length } from './functions/string.js';
+export { unnest } from './functions/unnest.js';
 export { coalesce } from './functions/util.js';
 export { cume_dist, dense_rank, first_value, lag, last_value, lead, nth_value, ntile, percent_rank, rank, row_number } from './functions/window.js';
 export { currentRow, following, frameGroups, frameRange, frameRows, preceding } from './functions/window-frame.js';
@@ -50,6 +60,8 @@ export { deepClone } from './visit/clone.js';
 export { rewrite } from './visit/rewrite.js';
 export { collectAggregates, collectColumns, collectParams, isAggregateExpression } from './visit/visitors.js';
 export { walk, type VisitorCallback, type VisitorResult } from './visit/walk.js';
+export { SQLCodeGenerator } from './visit/codegen/sql.js';
+export { DuckDBCodeGenerator, duckDBCodeGenerator } from './visit/codegen/duckdb.js';
 
 export { createTable, createSchema } from './load/create.js';
 export { loadExtension } from './load/extension.js';

package/src/init.ts

@@ -0,0 +1,5 @@
+import { setDefaultVisitor } from './ast/node.js';
+import { duckDBCodeGenerator } from './visit/codegen/duckdb.js';
+
+// Initialize the default visitor
+setDefaultVisitor(duckDBCodeGenerator);

package/src/transforms/filter-query.ts

@@ -3,6 +3,7 @@ import { isSelectQuery, type Query } from '../ast/query.js';
 import { isTableRef, type TableRefNode } from '../ast/table-ref.js';
 import { deepClone } from '../visit/clone.js';
 import { walk } from '../visit/walk.js';
+import { FromClauseNode } from '../ast/from.js';
 
 /**
  * Returns a generator function that clones the given query and adds
@@ -18,6 +19,7 @@ export function filterQuery(query: Query, tableRef: TableRefNode) {
       if (
         isSelectQuery(node) &&
         node._from.length === 1 &&
+        node._from[0] instanceof FromClauseNode &&
         isTableRef(node._from[0].expr) &&
         arrayEquals(node._from[0].expr.table, tableRef.table)
       ) {

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();