@uwdata/mosaic-sql 0.11.0 → 0.12.1

package/dist/mosaic-sql.js

@@ -1,74 +1,80 @@
-// src/ref.js
-var Ref = class {
+// src/constants.js
+var COLUMN_REF = "COLUMN_REF";
+var COLUMN_PARAM = "COLUMN_PARAM";
+var TABLE_REF = "TABLE_REF";
+var LITERAL = "LITERAL";
+var INTERVAL = "INTERVAL";
+var ORDER_BY = "ORDER_BY";
+var CAST = "CAST";
+var CASE = "CASE";
+var WHEN = "WHEN";
+var UNARY_OPERATOR = "UNARY";
+var UNARY_POSTFIX_OPERATOR = "UNARY_POSTFIX";
+var BINARY_OPERATOR = "BINARY";
+var BETWEEN_OPERATOR = "BETWEEN";
+var NOT_BETWEEN_OPERATOR = "NOT_BETWEEN";
+var LOGICAL_OPERATOR = "LOGICAL_OPERATOR";
+var IN_OPERATOR = "IN";
+var FUNCTION = "FUNCTION";
+var AGGREGATE = "AGGREGATE";
+var WINDOW = "WINDOW";
+var WINDOW_DEF = "WINDOW_DEF";
+var WINDOW_FRAME = "WINDOW_FRAME";
+var EXPRESSION = "EXPRESSION";
+var FRAGMENT = "FRAGMENT";
+var VERBATIM = "VERBATIM";
+var PARAM = "PARAM";
+var WITH_CLAUSE = "WITH_CLAUSE";
+var SELECT_CLAUSE = "SELECT_CLAUSE";
+var FROM_CLAUSE = "FROM_CLAUSE";
+var SAMPLE_CLAUSE = "SAMPLE_CLAUSE";
+var WINDOW_CLAUSE = "WINDOW_CLAUSE";
+var SELECT_QUERY = "SELECT_QUERY";
+var DESCRIBE_QUERY = "DESCRIBE_QUERY";
+var SET_OPERATION = "SET_OPERATION";
+
+// src/ast/node.js
+function isNode(value) {
+  return value instanceof SQLNode;
+}
+var SQLNode = class {
   /**
-   * Create a new Ref instance.
-   * @param {string|Ref|null} table The table name.
-   * @param {string|null} [column] The column name.
+   * Instantiate a SQL AST node.
+   * @param {string} type The SQL AST node type.
    */
-  constructor(table, column2) {
-    if (table) this.table = String(table);
-    if (column2) this.column = column2;
+  constructor(type) {
+    this.type = type;
   }
+};
+var ExprNode = class extends SQLNode {
+};
+
+// src/ast/literal.js
+var LiteralNode = class extends ExprNode {
   /**
-   * Get the list of referenced columns. Either a single element array
-   * if column is non-null, otherwise an empty array.
+   * Instantiate an literal node.
+   * @param {*} value The literal value.
    */
-  get columns() {
-    return this.column ? [this.column] : [];
+  constructor(value) {
+    super(LITERAL);
+    this.value = value;
   }
   /**
-   * Generate a SQL string for this reference.
-   * @returns {string} The SQL string.
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
   toString() {
-    const { table, column: column2 } = this;
-    if (column2) {
-      const col = column2.startsWith("*") ? column2 : `"${column2}"`;
-      return `${table ? `${quoteTableName(table)}.` : ""}${col}`;
-    } else {
-      return table ? quoteTableName(table) : "NULL";
-    }
+    return literalToSQL(this.value);
   }
 };
-function quoteTableName(table) {
-  const pieces = table.split(".");
-  return pieces.map((p) => `"${p}"`).join(".");
-}
-function isColumnRefFor(ref, name) {
-  return ref instanceof Ref && ref.column === name;
-}
-function asColumn(value) {
-  return typeof value === "string" ? column(value) : value;
-}
-function asRelation(value) {
-  return typeof value === "string" ? relation(value) : value;
-}
-function relation(name) {
-  return new Ref(name);
-}
-function column(table, column2 = null) {
-  if (arguments.length === 1) {
-    column2 = table;
-    table = null;
-  }
-  return new Ref(table, column2);
-}
-function all(table) {
-  return new Ref(table, "*");
-}
-
-// src/to-sql.js
-function toSQL(value) {
-  return typeof value === "string" ? `"${value}"` : literalToSQL(value);
-}
 function literalToSQL(value) {
   switch (typeof value) {
-    case "boolean":
-      return value ? "TRUE" : "FALSE";
+    case "number":
+      return Number.isFinite(value) ? `${value}` : "NULL";
     case "string":
       return `'${value.replace(`'`, `''`)}'`;
-    case "number":
-      return Number.isFinite(value) ? String(value) : "NULL";
+    case "boolean":
+      return value ? "TRUE" : "FALSE";
     default:
       if (value == null) {
         return "NULL";
@@ -78,1158 +84,2053 @@ function literalToSQL(value) {
         const y2 = value.getUTCFullYear();
         const m = value.getUTCMonth();
         const d = value.getUTCDate();
-        return ts === Date.UTC(y2, m, d) ? `MAKE_DATE(${y2}, ${m + 1}, ${d})` : `EPOCH_MS(${ts})`;
+        return ts === Date.UTC(y2, m, d) ? `DATE '${y2}-${m + 1}-${d}'` : `epoch_ms(${ts})`;
       } else if (value instanceof RegExp) {
         return `'${value.source}'`;
       } else {
-        return String(value);
+        return `${value}`;
       }
   }
 }
 
-// src/expression.js
-var isParamLike = (value) => typeof value?.addEventListener === "function";
-function isSQLExpression(value) {
-  return value instanceof SQLExpression;
-}
-var SQLExpression = class {
-  /**
-   * Create a new SQL expression instance.
-   * @param {(string | ParamLike | SQLExpression | import('./ref.js').Ref)[]} parts The parts of the expression.
-   * @param {string[]} [columns=[]] The column dependencies
-   * @param {object} [props] Additional properties for this expression.
-   */
-  constructor(parts, columns, props) {
-    this._expr = Array.isArray(parts) ? parts : [parts];
-    this._deps = columns || [];
-    this.annotate(props);
-    const params = this._expr.filter((part) => isParamLike(part));
-    if (params.length > 0) {
-      this._params = Array.from(new Set(params));
-      this._params.forEach((param) => {
-        param.addEventListener("value", () => update(this, this.map?.get("value")));
-      });
-    } else {
-      this.addEventListener = void 0;
-    }
+// src/ast/param.js
+var ParamNode = class extends ExprNode {
+  /**
+   * Instantiate a param node with a dynamic parameter.
+   * @param {import('../types.js').ParamLike} param The dynamic parameter.
+   */
+  constructor(param) {
+    super(PARAM);
+    this.param = param;
   }
   /**
-   * A reference to this expression.
-   * Provides compatibility with param-like objects.
+   * Returns the current parameter value.
+   * @returns {*}
    */
   get value() {
-    return this;
+    return this.param.value;
   }
   /**
-   * The column dependencies of this expression.
-   * @returns {string[]} The columns dependencies.
-   */
-  get columns() {
-    const { _params, _deps } = this;
-    if (_params) {
-      const pset = new Set(_params.flatMap((p) => {
-        const cols = p.value?.columns;
-        return Array.isArray(cols) ? cols : [];
-      }));
-      if (pset.size) {
-        const set = new Set(_deps);
-        pset.forEach((col) => set.add(col));
-        return Array.from(set);
-      }
-    }
-    return _deps;
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return literalToSQL(this.value);
   }
+};
+
+// src/util/string.js
+function parseIdentifier(id) {
+  return id.split(".");
+}
+function quoteIdentifier(value) {
+  return `"${value}"`;
+}
+function unquote(s) {
+  return s && isDoubleQuoted(s) ? s.slice(1, -1) : s;
+}
+function isDoubleQuoted(s) {
+  return s[0] === '"' && s[s.length - 1] === '"';
+}
+
+// src/ast/table-ref.js
+function isTableRef(value) {
+  return value instanceof TableRefNode;
+}
+var TableRefNode = class extends ExprNode {
   /**
-   * The first column dependency in this expression, or undefined if none.
-   * @returns {string} The first column dependency.
+   * Instantiate a table reference node.
+   * @param {string | string[]} table The table name.
    */
-  get column() {
-    return this._deps.length ? this._deps[0] : this.columns[0];
+  constructor(table) {
+    super(TABLE_REF);
+    this.table = [table].flat();
   }
   /**
-   * Annotate this expression instance with additional properties.
-   * @param {object[]} [props] One or more objects with properties to add.
-   * @returns This SQL expression.
+   * The table name without database or schema namespaces.
+   * @returns {string}
    */
-  annotate(...props) {
-    return Object.assign(this, ...props);
+  get name() {
+    return this.table[this.table.length - 1];
   }
   /**
-   * Generate a SQL code string corresponding to this expression.
-   * @returns {string} A SQL code string.
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
   toString() {
-    return this._expr.map((p) => isParamLike(p) && !isSQLExpression(p) ? literalToSQL(p.value) : p).join("");
+    return this.table.map((t) => quoteIdentifier(t)).join(".");
+  }
+};
+
+// src/ast/function.js
+var FunctionNode = class extends ExprNode {
+  /**
+   * Instantiate a function node.
+   * @param {string} name The function name.
+   * @param {ExprNode[]} [args=[]] The function arguments.
+   */
+  constructor(name, args = []) {
+    super(FUNCTION);
+    this.name = name;
+    this.args = args;
   }
   /**
-   * Add an event listener callback for the provided event type.
-   * @param {string} type The event type to listen for (for example, "value").
-   * @param {(a: SQLExpression) => Promise?} callback The callback function to
-   *  invoke upon updates. A callback may optionally return a Promise that
-   *  upstream listeners may await before proceeding.
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  addEventListener(type, callback) {
-    const map = this.map || (this.map = /* @__PURE__ */ new Map());
-    const set = map.get(type) || (map.set(type, /* @__PURE__ */ new Set()), map.get(type));
-    set.add(callback);
+  toString() {
+    const { name, args } = this;
+    return `${name}(${args.join(", ")})`;
   }
 };
-function update(expr, callbacks) {
-  if (callbacks?.size) {
-    return Promise.allSettled(Array.from(callbacks, (fn) => fn(expr)));
-  }
+
+// src/util/function.js
+function fn(name, ...args) {
+  return new FunctionNode(name, argsList(args).map(asNode));
 }
-function parseSQL(strings, exprs) {
-  const spans = [strings[0]];
-  const cols = /* @__PURE__ */ new Set();
-  const n = exprs.length;
-  for (let i = 0, k = 0; i < n; ) {
-    const e = exprs[i];
-    if (isParamLike(e)) {
-      spans[++k] = e;
-    } else {
-      if (Array.isArray(e?.columns)) {
-        e.columns.forEach((col) => cols.add(col));
-      }
-      spans[k] += typeof e === "string" ? e : literalToSQL(e);
-    }
-    const s = strings[++i];
-    if (isParamLike(spans[k])) {
-      spans[++k] = s;
-    } else {
-      spans[k] += s;
-    }
-  }
-  return { spans, cols: Array.from(cols) };
+function aggFn(name, ...args) {
+  return new AggregateNode(name, argsList(args).map(asNode));
 }
-function sql(strings, ...exprs) {
-  const { spans, cols } = parseSQL(strings, exprs);
-  return new SQLExpression(spans, cols);
+function winFn(name, ...args) {
+  return new WindowNode(
+    new WindowFunctionNode(name, argsList(args).map(asNode))
+  );
 }
-
-// src/desc.js
-function desc(expr) {
-  const e = asColumn(expr);
-  return sql`${e} DESC NULLS LAST`.annotate({ label: e?.label, desc: true });
+function exprList(list, cast2 = asNode) {
+  return list.flat().filter((x2) => x2 != null).map((x2) => cast2(x2));
 }
-
-// src/literal.js
-var literal = (value) => ({
-  value,
-  toString: () => literalToSQL(value)
-});
-
-// src/operators.js
-function visit(callback) {
-  callback(this.op, this);
-  this.children?.forEach((v) => v.visit(callback));
-}
-function logical(op, clauses) {
-  const children = clauses.filter((x2) => x2 != null).map(asColumn);
-  const strings = children.map((c, i) => i ? ` ${op} ` : "");
-  if (children.length === 1) {
-    strings.push("");
-  } else if (children.length > 1) {
-    strings[0] = "(";
-    strings.push(")");
-  }
-  return sql(strings, ...children).annotate({ op, children, visit });
-}
-var and = (...clauses) => logical("AND", clauses.flat());
-var or = (...clauses) => logical("OR", clauses.flat());
-var unaryOp = (op) => (a) => sql`(${op} ${asColumn(a)})`.annotate({ op, a, visit });
-var not = unaryOp("NOT");
-var unaryPostOp = (op) => (a) => sql`(${asColumn(a)} ${op})`.annotate({ op, a, visit });
-var isNull = unaryPostOp("IS NULL");
-var isNotNull = unaryPostOp("IS NOT NULL");
-var binaryOp = (op) => (a, b) => sql`(${asColumn(a)} ${op} ${asColumn(b)})`.annotate({ op, a, b, visit });
-var eq = binaryOp("=");
-var neq = binaryOp("<>");
-var lt = binaryOp("<");
-var gt = binaryOp(">");
-var lte = binaryOp("<=");
-var gte = binaryOp(">=");
-var isDistinct = binaryOp("IS DISTINCT FROM");
-var isNotDistinct = binaryOp("IS NOT DISTINCT FROM");
-function rangeOp(op, a, range, exclusive) {
-  a = asColumn(a);
-  const prefix2 = op.startsWith("NOT ") ? "NOT " : "";
-  const expr = !range ? sql`` : exclusive ? sql`${prefix2}(${range[0]} <= ${a} AND ${a} < ${range[1]})` : sql`(${a} ${op} ${range[0]} AND ${range[1]})`;
-  return expr.annotate({ op, visit, field: a, range });
-}
-var isBetween = (a, range, exclusive) => rangeOp("BETWEEN", a, range, exclusive);
-var isNotBetween = (a, range, exclusive) => rangeOp("NOT BETWEEN", a, range, exclusive);
-
-// src/repeat.js
-function repeat(length2, str) {
-  return Array.from({ length: length2 }, () => str);
+function argsList(list) {
+  const n = list.length;
+  let i = n;
+  for (; i > 0 && list[i - 1] === void 0; --i) ;
+  return i < n ? list.slice(0, i) : list;
 }
 
-// src/functions.js
-function functionCall(op, type) {
-  return (...values) => {
-    const args = values.map(asColumn);
-    const cast2 = type ? `::${type}` : "";
-    const expr = args.length ? sql([`${op}(`, ...repeat(args.length - 1, ", "), `)${cast2}`], ...args) : sql`${op}()${cast2}`;
-    return expr.annotate({ func: op, args });
-  };
+// src/util/type-check.js
+function isString(value) {
+  return typeof value === "string";
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isParamLike(value) {
+  return value && typeof value.addEventListener === "function" && value.dynamic !== false && "value" in value;
 }
-var regexp_matches = functionCall("REGEXP_MATCHES");
-var contains = functionCall("CONTAINS");
-var prefix = functionCall("PREFIX");
-var suffix = functionCall("SUFFIX");
-var lower = functionCall("LOWER");
-var upper = functionCall("UPPER");
-var length = functionCall("LENGTH");
-var isNaN = functionCall("ISNAN");
-var isFinite = functionCall("ISFINITE");
-var isInfinite = functionCall("ISINF");
 
-// src/windows.js
-var WindowFunction = class _WindowFunction extends SQLExpression {
-  /**
-   * Create a new WindowFunction instance.
-   * @param {string} op The window operation indicator.
-   * @param {*} func The window function expression.
-   * @param {*} [type] The SQL data type to cast to.
-   * @param {string} [name] The window definition name.
-   * @param {*} [group] Grouping (partition by) expressions.
-   * @param {*} [order] Sorting (order by) expressions.
-   * @param {*} [frame] The window frame definition.
-   */
-  constructor(op, func, type, name, group = "", order = "", frame = "") {
-    let expr;
-    const noWindowParams = !(group || order || frame);
-    if (name && noWindowParams) {
-      expr = name ? sql`${func} OVER "${name}"` : sql`${func} OVER ()`;
-    } else {
-      const s1 = group && order ? " " : "";
-      const s2 = (group || order) && frame ? " " : "";
-      expr = sql`${func} OVER (${name ? `"${name}" ` : ""}${group}${s1}${order}${s2}${frame})`;
-    }
-    if (type) {
-      expr = sql`(${expr})::${type}`;
-    }
-    const { _expr, _deps } = expr;
-    super(_expr, _deps);
-    this.window = op;
-    this.func = func;
-    this.type = type;
+// src/ast/window.js
+var WindowClauseNode = class extends SQLNode {
+  /**
+   * Instantiate a window clause node.
+   * @param {string} name The window name.
+   * @param {WindowDefNode} def The window definition.
+   */
+  constructor(name, def) {
+    super(WINDOW_CLAUSE);
     this.name = name;
-    this.group = group;
-    this.order = order;
-    this.frame = frame;
+    this.def = def;
   }
-  get basis() {
-    return this.column;
+  toString() {
+    return `${quoteIdentifier(this.name)} AS ${this.def}`;
   }
-  get label() {
-    const { func } = this;
-    return func.label ?? func.toString();
+};
+var WindowNode = class _WindowNode extends ExprNode {
+  /**
+   * Instantiate a window node.
+   * @param {WindowFunctionNode | AggregateNode} func The window function call.
+   * @param {WindowDefNode} [over] The window definition or name.
+   */
+  constructor(func, over2 = new WindowDefNode()) {
+    super(WINDOW);
+    this.func = func;
+    this.def = over2;
   }
   /**
-   * Return an updated window function over a named window definition.
+   * Return an updated window over a named window definition.
    * @param {string} name The window definition name.
-   * @returns {WindowFunction} A new window function.
+   * @returns {WindowNode} A new window node.
    */
   over(name) {
-    const { window: op, func, type, group, order, frame } = this;
-    return new _WindowFunction(op, func, type, name, group, order, frame);
+    return new _WindowNode(this.func, this.def.over(name));
   }
   /**
-   * Return an updated window function with the given partitioning.
-   * @param {*} expr The grouping (partition by) criteria for the window function.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window with the given partitions.
+   * @param {...import('../types.js').ExprVarArgs} expr The partition by criteria.
+   * @returns {WindowNode} A new window node.
    */
   partitionby(...expr) {
-    const exprs = expr.flat().filter((x2) => x2).map(asColumn);
-    const group = sql(
-      ["PARTITION BY ", repeat(exprs.length - 1, ", "), ""],
-      ...exprs
-    );
-    const { window: op, func, type, name, order, frame } = this;
-    return new _WindowFunction(op, func, type, name, group, order, frame);
+    return new _WindowNode(this.func, this.def.partitionby(...expr));
   }
   /**
-   * Return an updated window function with the given ordering.
-   * @param {*} expr The sorting (order by) criteria for the window function.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window with the given ordering.
+   * @param {...import('../types.js').ExprVarArgs} expr The order by criteria.
+   * @returns {WindowNode} A new window node.
    */
   orderby(...expr) {
-    const exprs = expr.flat().filter((x2) => x2).map(asColumn);
-    const order = sql(
-      ["ORDER BY ", repeat(exprs.length - 1, ", "), ""],
-      ...exprs
-    );
-    const { window: op, func, type, name, group, frame } = this;
-    return new _WindowFunction(op, func, type, name, group, order, frame);
+    return new _WindowNode(this.func, this.def.orderby(...expr));
   }
   /**
-   * Return an updated window function with the given rows frame.
-   * @param {(number|null)[] | import('./expression.js').ParamLike} expr The row-based window frame.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window with the given rows frame.
+   * @param {FrameExtent} extent The row-based window frame extent.
+   * @returns {WindowNode} A new window node.
    */
-  rows(expr) {
-    const frame = windowFrame("ROWS", expr);
-    const { window: op, func, type, name, group, order } = this;
-    return new _WindowFunction(op, func, type, name, group, order, frame);
+  rows(extent) {
+    return new _WindowNode(this.func, this.def.rows(extent));
   }
   /**
-   * Return an updated window function with the given range frame.
-   * @param {(number|null)[] | import('./expression.js').ParamLike} expr The range-based window frame.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window with the given range frame.
+   * @param {FrameExtent} extent The range-based window frame extent.
+   * @returns {WindowNode} A new window node.
    */
-  range(expr) {
-    const frame = windowFrame("RANGE", expr);
-    const { window: op, func, type, name, group, order } = this;
-    return new _WindowFunction(op, func, type, name, group, order, frame);
-  }
-};
-function windowFrame(type, frame) {
-  if (isParamLike(frame)) {
-    const expr = sql`${frame}`;
-    expr.toString = () => `${type} ${frameToSQL(frame.value)}`;
-    return expr;
-  }
-  return `${type} ${frameToSQL(frame)}`;
-}
-function frameToSQL(frame) {
-  const [prev, next] = frame;
-  const a = prev === 0 ? "CURRENT ROW" : Number.isFinite(prev) ? `${Math.abs(prev)} PRECEDING` : "UNBOUNDED PRECEDING";
-  const b = next === 0 ? "CURRENT ROW" : Number.isFinite(next) ? `${Math.abs(next)} FOLLOWING` : "UNBOUNDED FOLLOWING";
-  return `BETWEEN ${a} AND ${b}`;
-}
-function winf(op, type) {
-  return (...values) => {
-    const func = functionCall(op)(...values);
-    return new WindowFunction(op, func, type);
-  };
-}
-var row_number = winf("ROW_NUMBER", "INTEGER");
-var rank = winf("RANK", "INTEGER");
-var dense_rank = winf("DENSE_RANK", "INTEGER");
-var percent_rank = winf("PERCENT_RANK");
-var cume_dist = winf("CUME_DIST");
-var ntile = winf("NTILE");
-var lag = winf("LAG");
-var lead = winf("LEAD");
-var first_value = winf("FIRST_VALUE");
-var last_value = winf("LAST_VALUE");
-var nth_value = winf("NTH_VALUE");
-
-// src/aggregates.js
-function agg(strings, ...exprs) {
-  return sql(strings, ...exprs).annotate({ aggregate: true });
-}
-var AggregateFunction = class _AggregateFunction extends SQLExpression {
-  /**
-   * Create a new AggregateFunction instance.
-   * @param {*} op The aggregate operation.
-   * @param {*} [args] The aggregate function arguments.
-   * @param {*} [type] The SQL data type to cast to.
-   * @param {boolean} [isDistinct] Flag indicating if this is a distinct value aggregate.
-   * @param {*} [filter] Filtering expression to apply prior to aggregation.
-   */
-  constructor(op, args, type, isDistinct2, filter) {
-    args = (args || []).map(asColumn);
-    const { strings, exprs } = aggExpr(op, args, type, isDistinct2, filter);
-    const { spans, cols } = parseSQL(strings, exprs);
-    super(spans, cols);
-    this.aggregate = op;
-    this.args = args;
-    this.type = type;
-    this.isDistinct = isDistinct2;
-    this.filter = filter;
+  range(extent) {
+    return new _WindowNode(this.func, this.def.range(extent));
   }
-  get basis() {
-    return this.column;
-  }
-  get label() {
-    const { aggregate: op, args, isDistinct: isDistinct2 } = this;
-    const dist = isDistinct2 ? "DISTINCT" + (args.length ? " " : "") : "";
-    const tail = args.length ? `(${dist}${args.map(unquoted).join(", ")})` : "";
-    return `${op.toLowerCase()}${tail}`;
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `${this.func} OVER ${this.def}`;
   }
+};
+var WindowFunctionNode = class extends FunctionNode {
   /**
-   * Return a new derived aggregate function over distinct values.
-   * @returns {AggregateFunction} A new aggregate function.
+   * Instantiate a window function call node.
+   * @param {import('../types.js').WindowFunctionName} name The function name.
+   * @param {ExprNode[]} [args=[]] The function arguments.
    */
-  distinct() {
-    const { aggregate: op, args, type, filter } = this;
-    return new _AggregateFunction(op, args, type, true, filter);
+  constructor(name, args) {
+    super(name, args);
   }
+};
+var WindowDefNode = class extends SQLNode {
   /**
-   * Return a new derived aggregate function that filters values.
-   * @param {*} filter The filter expresion.
-   * @returns {AggregateFunction} A new aggregate function.
+   * Instantiate a window definition node.
+   * @param {string} [name] The base window definition name.
+   * @param {ExprNode[]} [partition] The partition by criteria.
+   * @param {ExprNode[]} [order] The order by criteria.
+   * @param {WindowFrameNode} [frame] The window frame definition.
    */
-  where(filter) {
-    const { aggregate: op, args, type, isDistinct: isDistinct2 } = this;
-    return new _AggregateFunction(op, args, type, isDistinct2, filter);
+  constructor(name, partition, order, frame) {
+    super(WINDOW_DEF);
+    this.name = name;
+    this.partition = partition;
+    this.order = order;
+    this.frame = frame;
   }
   /**
-   * Return a new window function over this aggregate.
-   * @returns {WindowFunction} A new aggregate function.
+   * Return an updated window definition with the given base name.
+   * @param {string} name The base window definition name.
+   * @returns {WindowDefNode} A new window definition node.
    */
-  window() {
-    const { aggregate: op, args, type, isDistinct: isDistinct2 } = this;
-    const func = new _AggregateFunction(op, args, null, isDistinct2);
-    return new WindowFunction(op, func, type);
+  over(name) {
+    return deriveDef(this, { name });
   }
   /**
-   * Return a window function over this aggregate with the given partitioning.
-   * @param {*} expr The grouping (partition by) criteria for the window function.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window definition with the given partitions.
+   * @param {...import('../types.js').ExprVarArgs} expr The partition by criteria.
+   * @returns {WindowDefNode} A new window definition node.
    */
   partitionby(...expr) {
-    return this.window().partitionby(...expr);
+    return deriveDef(this, { partition: exprList(expr) });
   }
   /**
-   * Return a window function over this aggregate with the given ordering.
-   * @param {*} expr The sorting (order by) criteria for the window function.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window definition with the given ordering.
+   * @param {...import('../types.js').ExprVarArgs} expr The order by criteria.
+   * @returns {WindowDefNode} A new window definition node.
    */
   orderby(...expr) {
-    return this.window().orderby(...expr);
+    return deriveDef(this, { order: exprList(expr) });
   }
   /**
-   * Return a window function over this aggregate with the given row frame.
-   * @param {(number|null)[] | import('./expression.js').ParamLike} frame The row-based window frame.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window definition with the given rows frame.
+   * @param {FrameExtent} extent The row-based window frame extent.
+   * @returns {WindowDefNode} A new window definition node.
    */
-  rows(frame) {
-    return this.window().rows(frame);
+  rows(extent) {
+    return deriveDef(this, { frame: new WindowFrameNode(extent) });
   }
   /**
-   * Return a window function over this aggregate with the given range frame.
-   * @param {(number|null)[] | import('./expression.js').ParamLike} frame The range-based window frame.
-   * @returns {WindowFunction} A new window function.
+   * Return an updated window definition with the given range frame.
+   * @param {FrameExtent} extent The range-based window frame extent.
+   * @returns {WindowDefNode} A new window definition node.
    */
-  range(frame) {
-    return this.window().range(frame);
-  }
-};
-function aggExpr(op, args, type, isDistinct2, filter) {
-  const close = `)${type ? `::${type}` : ""}`;
-  let strings = [`${op}(${isDistinct2 ? "DISTINCT " : ""}`];
-  let exprs = [];
-  if (args.length) {
-    strings = strings.concat([
-      ...repeat(args.length - 1, ", "),
-      `${close}${filter ? " FILTER (WHERE " : ""}`,
-      ...filter ? [")"] : []
-    ]);
-    exprs = [...args, ...filter ? [filter] : []];
-  } else {
-    strings[0] += "*" + close;
-  }
-  return { exprs, strings };
-}
-function unquoted(value) {
-  const s = literalToSQL(value);
-  return s && s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
-}
-function aggf(op, type) {
-  return (...args) => new AggregateFunction(op, args, type);
-}
-var count = aggf("COUNT", "INTEGER");
-var avg = aggf("AVG");
-var mean = aggf("AVG");
-var mad = aggf("MAD");
-var max = aggf("MAX");
-var min = aggf("MIN");
-var sum = aggf("SUM", "DOUBLE");
-var product = aggf("PRODUCT");
-var median = aggf("MEDIAN");
-var quantile = aggf("QUANTILE");
-var mode = aggf("MODE");
-var variance = aggf("VARIANCE");
-var stddev = aggf("STDDEV");
-var skewness = aggf("SKEWNESS");
-var kurtosis = aggf("KURTOSIS");
-var entropy = aggf("ENTROPY");
-var varPop = aggf("VAR_POP");
-var stddevPop = aggf("STDDEV_POP");
-var corr = aggf("CORR");
-var covariance = aggf("COVAR_SAMP");
-var covarPop = aggf("COVAR_POP");
-var regrIntercept = aggf("REGR_INTERCEPT");
-var regrSlope = aggf("REGR_SLOPE");
-var regrCount = aggf("REGR_COUNT");
-var regrR2 = aggf("REGR_R2");
-var regrSYY = aggf("REGR_SYY");
-var regrSXX = aggf("REGR_SXX");
-var regrSXY = aggf("REGR_SXY");
-var regrAvgX = aggf("REGR_AVGX");
-var regrAvgY = aggf("REGR_AVGY");
-var first = aggf("FIRST");
-var last = aggf("LAST");
-var argmin = aggf("ARG_MIN");
-var argmax = aggf("ARG_MAX");
-var stringAgg = aggf("STRING_AGG");
-var arrayAgg = aggf("ARRAY_AGG");
-
-// src/cast.js
-function cast(expr, type) {
-  const arg = asColumn(expr);
-  const e = sql`CAST(${arg} AS ${type})`;
-  Object.defineProperty(e, "label", {
-    enumerable: true,
-    get() {
-      return expr.label;
-    }
-  });
-  Object.defineProperty(e, "aggregate", {
-    enumerable: true,
-    get() {
-      return expr.aggregate || false;
-    }
-  });
-  return e;
-}
-var castDouble = (expr) => cast(expr, "DOUBLE");
-var castInteger = (expr) => cast(expr, "INTEGER");
-
-// src/datetime.js
-var epoch_ms = (expr) => {
-  return sql`epoch_ms(${asColumn(expr)})`;
-};
-function dateBin(expr, interval, steps = 1) {
-  const i = `INTERVAL ${steps} ${interval}`;
-  const d = asColumn(expr);
-  return sql`TIME_BUCKET(${i}, ${d})`.annotate({ label: interval });
-}
-var dateMonth = (expr) => {
-  const d = asColumn(expr);
-  return sql`MAKE_DATE(2012, MONTH(${d}), 1)`.annotate({ label: "month" });
-};
-var dateMonthDay = (expr) => {
-  const d = asColumn(expr);
-  return sql`MAKE_DATE(2012, MONTH(${d}), DAY(${d}))`.annotate({ label: "date" });
-};
-var dateDay = (expr) => {
-  const d = asColumn(expr);
-  return sql`MAKE_DATE(2012, 1, DAY(${d}))`.annotate({ label: "date" });
-};
-
-// src/spatial.js
-var geojson = functionCall("ST_AsGeoJSON");
-var x = functionCall("ST_X");
-var y = functionCall("ST_Y");
-var centroid = functionCall("ST_CENTROID");
-var centroidX = (geom) => x(centroid(geom));
-var centroidY = (geom) => y(centroid(geom));
-
-// src/Query.js
-var Query = class _Query {
-  static select(...expr) {
-    return new _Query().select(...expr);
-  }
-  static from(...expr) {
-    return new _Query().from(...expr);
-  }
-  static with(...expr) {
-    return new _Query().with(...expr);
-  }
-  static union(...queries) {
-    return new SetOperation("UNION", queries.flat());
-  }
-  static unionAll(...queries) {
-    return new SetOperation("UNION ALL", queries.flat());
-  }
-  static intersect(...queries) {
-    return new SetOperation("INTERSECT", queries.flat());
-  }
-  static except(...queries) {
-    return new SetOperation("EXCEPT", queries.flat());
-  }
-  static describe(query) {
-    const q = query.clone();
-    const { clone, toString } = q;
-    return Object.assign(q, {
-      describe: true,
-      clone: () => _Query.describe(clone.call(q)),
-      toString: () => `DESCRIBE ${toString.call(q)}`
-    });
-  }
-  constructor() {
-    this.query = {
-      with: [],
-      select: [],
-      from: [],
-      where: [],
-      groupby: [],
-      having: [],
-      window: [],
-      qualify: [],
-      orderby: []
-    };
-    this.cteFor = null;
-  }
-  clone() {
-    const q = new _Query();
-    q.query = { ...this.query };
-    return q;
+  range(extent) {
+    return deriveDef(this, { frame: new WindowFrameNode(extent, true) });
   }
   /**
-   * Retrieve current WITH common table expressions (CTEs).
-   * @returns {any[]}
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  /**
-  * Add WITH common table expressions (CTEs).
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  with(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.with;
-    } else {
-      const list = [];
-      const add = (as, q) => {
-        const query2 = q.clone();
-        query2.cteFor = this;
-        list.push({ as, query: query2 });
-      };
-      expr.flat().forEach((e) => {
-        if (e == null) {
-        } else if (e.as && e.query) {
-          add(e.as, e.query);
-        } else {
-          for (const as in e) {
-            add(as, e[as]);
-          }
-        }
-      });
-      query.with = query.with.concat(list);
-      return this;
-    }
+  toString() {
+    const { name, partition, order, frame } = this;
+    const base = name && quoteIdentifier(name);
+    const def = [
+      base,
+      partition?.length && `PARTITION BY ${partition.join(", ")}`,
+      order?.length && `ORDER BY ${order.join(", ")}`,
+      frame
+    ].filter((x2) => x2);
+    return base && def.length < 2 ? base : `(${def.join(" ")})`;
   }
+};
+var WindowFrameNode = class extends SQLNode {
   /**
-   * Retrieve current SELECT expressions.
-   * @returns {any[]}
+   * Instantiate a window frame definition node.
+   * @param {FrameExtent} extent The frame extent as [preceding, following]
+   *  row or interval offsets.
+   * @param {boolean} [range] The frame type: `true` for range, otherwise rows.
+   * @param {ExprNode} [exclude] The window exclusion criteria.
    */
-  /**
-  * Add SELECT expressions.
-  * @param {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  select(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.select;
-    } else {
-      const list = [];
-      for (const e of expr.flat()) {
-        if (e == null) {
-        } else if (typeof e === "string") {
-          list.push({ as: e, expr: asColumn(e) });
-        } else if (e instanceof Ref) {
-          list.push({ as: e.column, expr: e });
-        } else if (Array.isArray(e)) {
-          list.push({ as: e[0], expr: e[1] });
-        } else {
-          for (const as in e) {
-            list.push({ as: unquote(as), expr: asColumn(e[as]) });
-          }
-        }
-      }
-      const keys = new Set(list.map((x2) => x2.as));
-      query.select = query.select.filter((x2) => !keys.has(x2.as)).concat(list.filter((x2) => x2.expr));
-      return this;
-    }
-  }
-  $select(...expr) {
-    this.query.select = [];
-    return this.select(...expr);
-  }
-  distinct(value = true) {
-    this.query.distinct = !!value;
-    return this;
+  constructor(extent, range = false, exclude = void 0) {
+    super(WINDOW_FRAME);
+    this.extent = isParamLike(extent) ? new ParamNode(extent) : extent;
+    this.range = range;
+    this.exclude = exclude;
   }
   /**
-   * Retrieve current from expressions.
-   * @returns {any[]}
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  /**
-  * Provide table from expressions.
-  * @param  {...any} expr
-  * @returns {this}
-  */
-  from(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.from;
-    } else {
-      const list = [];
-      expr.flat().forEach((e) => {
-        if (e == null) {
-        } else if (typeof e === "string") {
-          list.push({ as: e, from: asRelation(e) });
-        } else if (e instanceof Ref) {
-          list.push({ as: e.table, from: e });
-        } else if (isQuery(e) || isSQLExpression(e)) {
-          list.push({ from: e });
-        } else if (Array.isArray(e)) {
-          list.push({ as: unquote(e[0]), from: asRelation(e[1]) });
-        } else {
-          for (const as in e) {
-            list.push({ as: unquote(as), from: asRelation(e[as]) });
-          }
-        }
-      });
-      query.from = query.from.concat(list);
-      return this;
-    }
-  }
-  $from(...expr) {
-    this.query.from = [];
-    return this.from(...expr);
+  toString() {
+    const { range, exclude, extent } = this;
+    const type = range ? "RANGE" : "ROWS";
+    const [prev, next] = isNode(extent) ? extent.value : extent;
+    const a = frameValue(prev, "PRECEDING");
+    const b = frameValue(next, "FOLLOWING");
+    return `${type} BETWEEN ${a} AND ${b}${exclude ? ` ${exclude}` : ""}`;
   }
+};
+function deriveDef(def, options) {
+  return new WindowDefNode(
+    options.name ?? def.name,
+    options.partition ?? def.partition,
+    options.order ?? def.order,
+    options.frame ?? def.frame
+  );
+}
+function frameValue(value, order) {
+  return value === 0 ? "CURRENT ROW" : Number.isFinite(value) ? `${Math.abs(value)} ${order}` : `UNBOUNDED ${order}`;
+}
+
+// src/ast/column-ref.js
+function isColumnRef(value) {
+  return value instanceof ColumnRefNode;
+}
+var ColumnRefNode = class extends ExprNode {
   /**
-   * Retrieve current SAMPLE settings.
-   * @returns {any[]}
+   * Instantiate a column reference node.
+   * @param {import('./table-ref.js').TableRefNode} [table] The table reference.
    */
-  /**
-  * Set SAMPLE settings.
-  * @param {number|object} value The percentage or number of rows to sample.
-  * @param {string} [method] The sampling method to use.
-  * @returns {this}
-  */
-  sample(value, method) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.sample;
-    } else {
-      let spec = value;
-      if (typeof value === "number") {
-        spec = value > 0 && value < 1 ? { perc: 100 * value, method } : { rows: Math.round(value), method };
-      }
-      query.sample = spec;
-      return this;
-    }
+  constructor(type, table) {
+    super(type);
+    this.table = table;
   }
   /**
-   * Retrieve current WHERE expressions.
-   * @returns {any[]}
+   * Returns the column name.
+   * @returns {string}
    */
-  /**
-  * Add WHERE expressions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  where(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.where;
-    } else {
-      query.where = query.where.concat(
-        expr.flat().filter((x2) => x2)
-      );
-      return this;
-    }
-  }
-  $where(...expr) {
-    this.query.where = [];
-    return this.where(...expr);
+  get column() {
+    return null;
   }
   /**
-   * Retrieve current GROUP BY expressions.
-   * @returns {any[]}
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  /**
-  * Add GROUP BY expressions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  groupby(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.groupby;
-    } else {
-      query.groupby = query.groupby.concat(
-        expr.flat().filter((x2) => x2).map(asColumn)
-      );
-      return this;
-    }
-  }
-  $groupby(...expr) {
-    this.query.groupby = [];
-    return this.groupby(...expr);
+  toString() {
+    const { column: column2, table } = this;
+    const tref = `${table ?? ""}`;
+    const id = column2 === "*" ? "*" : quoteIdentifier(column2);
+    return (tref ? tref + "." : "") + id;
   }
+};
+var ColumnNameRefNode = class extends ColumnRefNode {
   /**
-   * Retrieve current HAVING expressions.
-   * @returns {any[]}
+   * Instantiate a column reference node.
+   * @param {string} name The column name.
+   * @param {import('./table-ref.js').TableRefNode} [table] The table reference.
    */
-  /**
-  * Add HAVING expressions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  having(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.having;
-    } else {
-      query.having = query.having.concat(
-        expr.flat().filter((x2) => x2)
-      );
-      return this;
-    }
+  constructor(name, table) {
+    super(COLUMN_REF, table);
+    this.name = name;
   }
   /**
-   * Retrieve current WINDOW definitions.
-   * @returns {any[]}
+   * Returns the column name.
+   * @returns {string}
    */
-  /**
-  * Add WINDOW definitions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  window(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.window;
-    } else {
-      const list = [];
-      expr.flat().forEach((e) => {
-        if (e == null) {
-        } else {
-          for (const as in e) {
-            list.push({ as: unquote(as), expr: e[as] });
-          }
-        }
-      });
-      query.window = query.window.concat(list);
-      return this;
-    }
+  get column() {
+    return this.name;
   }
+};
+
+// src/ast/column-param.js
+var ColumnParamNode = class extends ColumnRefNode {
   /**
-   * Retrieve current QUALIFY expressions.
-   * @returns {any[]}
+   * Instantiate a column param node.
+   * @param {import('./param.js').ParamNode} param The column name as a
+   *  parameter node.
+   * @param {import('./table-ref.js').TableRefNode} [table] The table
+   *  reference.
    */
-  /**
-  * Add QUALIFY expressions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  qualify(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.qualify;
-    } else {
-      query.qualify = query.qualify.concat(
-        expr.flat().filter((x2) => x2)
-      );
-      return this;
-    }
+  constructor(param, table) {
+    super(COLUMN_PARAM, table);
+    this.param = param;
   }
   /**
-   * Retrieve current ORDER BY expressions.
-   * @returns {any[]}
+   * Returns the column name.
+   * @returns {string}
    */
-  /**
-  * Add ORDER BY expressions.
-  * @param  {...any} expr Expressions to add.
-  * @returns {this}
-  */
-  orderby(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.orderby;
-    } else {
-      query.orderby = query.orderby.concat(
-        expr.flat().filter((x2) => x2).map(asColumn)
-      );
-      return this;
-    }
+  get column() {
+    return `${this.param.value}`;
   }
+};
+
+// src/functions/column.js
+function column(name, table) {
+  const tref = asTableRef(table);
+  return isParamLike(name) ? new ColumnParamNode(new ParamNode(name), tref) : new ColumnNameRefNode(name, tref);
+}
+
+// src/ast/verbatim.js
+var VerbatimNode = class extends ExprNode {
   /**
-   * Retrieve current LIMIT value.
-   * @returns {number|null}
+   * Instantiate a raw node with verbatim content.
+   * @param {string} value The verbatim content to include.
    */
-  /**
-  * Set the query result LIMIT.
-  * @param {number} value The limit value.
-  * @returns {this}
-  */
-  limit(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.limit;
-    } else {
-      query.limit = Number.isFinite(value) ? value : void 0;
-      return this;
-    }
+  constructor(value) {
+    super(VERBATIM);
+    this.value = value;
   }
   /**
-   * Retrieve current OFFSET value.
-   * @returns {number|null}
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  /**
-  * Set the query result OFFSET.
-  * @param {number} value The offset value.
-  * @returns {this}
-  */
-  offset(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.offset;
-    } else {
-      query.offset = Number.isFinite(value) ? value : void 0;
-      return this;
-    }
-  }
-  get subqueries() {
-    const { query, cteFor } = this;
-    const ctes = (cteFor?.query || query).with;
-    const cte = ctes?.reduce((o, { as, query: query2 }) => (o[as] = query2, o), {});
-    const q = [];
-    query.from.forEach(({ from }) => {
-      if (isQuery(from)) {
-        q.push(from);
-      } else if (cte[from.table]) {
-        const sub = cte[from.table];
-        q.push(sub);
-      }
-    });
-    return q;
-  }
   toString() {
-    const {
-      with: cte,
-      select,
-      distinct,
-      from,
-      sample,
-      where,
-      groupby,
-      having,
-      window,
-      qualify,
-      orderby,
-      limit,
-      offset
-    } = this.query;
-    const sql2 = [];
-    if (cte.length) {
-      const list = cte.map(({ as, query }) => `"${as}" AS (${query})`);
-      sql2.push(`WITH ${list.join(", ")}`);
-    }
-    const sels = select.map(
-      ({ as, expr }) => isColumnRefFor(expr, as) && !expr.table ? `${expr}` : `${expr} AS "${as}"`
+    return this.value;
+  }
+};
+
+// src/functions/literal.js
+function literal(value) {
+  return new LiteralNode(value);
+}
+function verbatim(value) {
+  return new VerbatimNode(value);
+}
+
+// src/functions/table-ref.js
+function tableRef(...ids) {
+  const args = exprList(ids, String);
+  return args?.length ? new TableRefNode(args) : void 0;
+}
+
+// src/util/ast.js
+function asNode(value) {
+  return isString(value) ? parseColumnRef(value) : asLiteral(value);
+}
+function asVerbatim(value) {
+  return isString(value) ? verbatim(value) : asLiteral(value);
+}
+function asLiteral(value) {
+  return value instanceof ExprNode ? value : isParamLike(value) ? new ParamNode(value) : literal(value);
+}
+function asTableRef(value) {
+  return isString(value) ? parseTableRef(value) : isArray(value) ? tableRef(value) : value;
+}
+function parseColumnRef(ref) {
+  const ids = parseIdentifier(ref);
+  return column(ids.pop(), tableRef(ids));
+}
+function parseTableRef(ref) {
+  return tableRef(parseIdentifier(ref));
+}
+function over() {
+  return new WindowDefNode();
+}
+
+// src/ast/aggregate.js
+var AggregateNode = class _AggregateNode extends ExprNode {
+  /**
+   * Instantiate an aggregate function node.
+   * @param {string} name The aggregate function name.
+   * @param {ExprNode[]} args The aggregate function arguments.
+   * @param {boolean} [distinct] The distinct flag.
+   * @param {ExprNode} [filter] Filter expression.
+   */
+  constructor(name, args, distinct, filter) {
+    super(AGGREGATE);
+    this.name = name;
+    this.args = args;
+    this.isDistinct = distinct;
+    this.filter = filter;
+  }
+  /**
+   * Return a new derived aggregate over distinct values.
+   * @param {boolean} [isDistinct=true] The distinct flag.
+   * @returns {AggregateNode} A new aggregate node.
+   */
+  distinct(isDistinct2 = true) {
+    return new _AggregateNode(this.name, this.args, isDistinct2, this.filter);
+  }
+  /**
+   * Return a new derived aggregate function that filters values.
+   * @param {ExprNode | string} filter The filter expression.
+   * @returns {AggregateNode} A new aggregate node.
+   */
+  where(filter) {
+    if (isString(filter)) filter = asVerbatim(filter);
+    return new _AggregateNode(this.name, this.args, this.isDistinct, filter);
+  }
+  /**
+   * Return a new window function over this aggregate.
+   * @returns {WindowNode} A new window node.
+   */
+  window() {
+    return new WindowNode(this);
+  }
+  /**
+   * Return a new window function over this aggregate with the given partitions.
+   * @param {...import('../types.js').ExprVarArgs} expr The partition by criteria.
+   * @returns {WindowNode} A new window node.
+   */
+  partitionby(...expr) {
+    return this.window().partitionby(...expr);
+  }
+  /**
+   * Return a new window function over this aggregate with the given ordering.
+   * @param {...import('../types.js').ExprVarArgs} expr The order by criteria.
+   * @returns {WindowNode} A new window node.
+   */
+  orderby(...expr) {
+    return this.window().orderby(...expr);
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { name, args, isDistinct: isDistinct2, filter } = this;
+    const dist = isDistinct2 ? "DISTINCT " : "";
+    const arg = args?.length ? args.join(", ") : "*";
+    const filt = filter ? ` FILTER (WHERE ${filter})` : "";
+    return `${name}(${dist}${arg})${filt}`;
+  }
+};
+var aggregateNames = [
+  "any_value",
+  "approx_count_distinct",
+  "approx_quantile",
+  "arbitrary",
+  "arg_max",
+  "arg_max_null",
+  "arg_min",
+  "arg_min_null",
+  "array_agg",
+  "avg",
+  "bit_and",
+  "bit_or",
+  "bit_xor",
+  "bitstring_agg",
+  "bool_and",
+  "bool_or",
+  "corr",
+  "count",
+  "covar_pop",
+  "covar_samp",
+  "entropy",
+  "favg",
+  "first",
+  "fsum",
+  "geomean",
+  "kurtosis_pop",
+  "kurtosis",
+  "last",
+  "mad",
+  "max",
+  "max_by",
+  "median",
+  "min",
+  "min_by",
+  "mode",
+  "product",
+  "quantile",
+  "quantile_cont",
+  "quantile_disc",
+  "regr_avgx",
+  "regr_avgy",
+  "regr_count",
+  "regr_intercept",
+  "regr_r2",
+  "regr_sxx",
+  "regr_sxy",
+  "regr_syy",
+  "regr_slope",
+  "reservoir_quantile",
+  "skewness",
+  "stddev",
+  "stddev_pop",
+  "stddev_samp",
+  "string_agg",
+  "sum",
+  "variance",
+  "var_pop",
+  "var_samp"
+];
+
+// src/ast/between-op.js
+var AbstractBetweenOpNode = class extends ExprNode {
+  /**
+   * Instantiate an abstract between operator node.
+   * @param {string} type The node type.
+   * @param {ExprNode} expr The input expression.
+   * @param {[ExprNode, ExprNode]} extent The range extent.
+   */
+  constructor(type, expr, extent) {
+    super(type);
+    this.expr = expr;
+    this.extent = extent;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toSQL(op) {
+    const { extent: r, expr } = this;
+    return r ? `(${expr} ${op} ${r[0]} AND ${r[1]})` : "";
+  }
+};
+var BetweenOpNode = class extends AbstractBetweenOpNode {
+  /**
+   * Instantiate a between operator node.
+   * @param {ExprNode} expr The input expression.
+   * @param {[ExprNode, ExprNode]} extent
+   *  The range extent.
+   */
+  constructor(expr, extent) {
+    super(BETWEEN_OPERATOR, expr, extent);
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return super.toSQL("BETWEEN");
+  }
+};
+var NotBetweenOpNode = class extends AbstractBetweenOpNode {
+  /**
+   * Instantiate a not between operator node.
+   * @param {ExprNode} expr The input expression.
+   * @param {[ExprNode, ExprNode]} extent
+   *  The range extent.
+   */
+  constructor(expr, extent) {
+    super(NOT_BETWEEN_OPERATOR, expr, extent);
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return super.toSQL("NOT BETWEEN");
+  }
+};
+
+// src/ast/binary-op.js
+var BinaryOpNode = class extends ExprNode {
+  /**
+   * Instantiate a binary operator node.
+   * @param {string} op The operator type.
+   * @param {ExprNode} left The left input expression.
+   * @param {ExprNode} right The right input expression.
+   */
+  constructor(op, left, right) {
+    super(BINARY_OPERATOR);
+    this.op = op;
+    this.left = left;
+    this.right = right;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.left} ${this.op} ${this.right})`;
+  }
+};
+
+// src/ast/case.js
+var CaseNode = class _CaseNode extends ExprNode {
+  /**
+   * Instantiate a case node.
+   * @param {ExprNode} [expr] An optional base expression, that comes
+   *  immediately after the CASE keyword. If specified, this case statement
+   *  acts like a switch statement, with WHEN expressions as values to
+   *  match against the switch value rather than boolean conditions.
+   * @param {WhenNode[]} [when] An array of WHEN/THEN expression nodes.
+   * @param {ExprNode} [elseExpr] An ELSE expression.
+   */
+  constructor(expr = void 0, when = [], elseExpr = void 0) {
+    super(CASE);
+    this.expr = expr;
+    this._when = when;
+    this._else = elseExpr;
+  }
+  /**
+   * Return a new case node with the given conditional added as
+   * the last WHEN / THEN pair.
+   * @param {import('../types.js').ExprValue} cond
+   *  The WHEN condition expression.
+   * @param {import('../types.js').ExprValue} value
+   *  The THEN value expression.
+   * @returns {CaseNode}
+   */
+  when(cond2, value) {
+    return new _CaseNode(
+      this.expr,
+      this._when.concat(new WhenNode(asNode(cond2), asNode(value))),
+      this._else
+    );
+  }
+  /**
+   * Return a new case node with the given ELSE expression.
+   * @param {import('../types.js').ExprValue} expr The ELSE expression.
+   * @returns {CaseNode}
+   */
+  else(expr) {
+    return new _CaseNode(this.expr, this._when, asNode(expr));
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return "CASE " + (this.expr ? `${this.expr} ` : "") + this._when.join(" ") + (this._else ? ` ELSE ${this._else}` : "") + " END";
+  }
+};
+var WhenNode = class extends SQLNode {
+  /**
+   * Instantiate a case node.
+   * @param {ExprNode} when The WHEN condition expression.
+   * @param {ExprNode} then The THEN value expression.
+   */
+  constructor(when, then) {
+    super(WHEN);
+    this.when = when;
+    this.then = then;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `WHEN ${this.when} THEN ${this.then}`;
+  }
+};
+
+// src/ast/cast.js
+var CastNode = class extends ExprNode {
+  /**
+   * Instantiate a cast node.
+   * @param {ExprNode} expr The expression to type cast.
+   * @param {string} type The type to cast to.
+   */
+  constructor(expr, type) {
+    super(CAST);
+    this.expr = expr;
+    this.cast = type;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.expr})::${this.cast}`;
+  }
+};
+
+// src/ast/fragment.js
+var FragmentNode = class extends ExprNode {
+  /**
+   * Instantiate a fragment node with arbitrary content.
+   * @param {ExprNode[]} spans The consecutive parts making up the fragment.
+   */
+  constructor(spans) {
+    super(FRAGMENT);
+    this.spans = spans;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return this.spans.join("");
+  }
+};
+
+// src/ast/sample.js
+var SampleClauseNode = class extends SQLNode {
+  /**
+   * Instantiate a sample clause node.
+   * @param {number} size The sample size as either a row count or percentage.
+   * @param {boolean} [perc=false] Flag indicating if the sampling unit is
+   *   rows (`false`) or a percentage (`true`).
+   * @param {SampleMethod} [method] The sampling method. If unspecified,
+   *   a default method is applied based on the sampling unit.
+   * @param {number} [seed] The random seed.
+   */
+  constructor(size, perc = false, method = void 0, seed = void 0) {
+    super(SAMPLE_CLAUSE);
+    this.size = size;
+    this.perc = perc;
+    this.method = method;
+    this.seed = seed;
+  }
+  toString() {
+    const { size, perc, method, seed } = this;
+    const unit = perc ? "%" : " ROWS";
+    const s = seed != null ? `, ${seed}` : "";
+    return `${size}${unit}${method ? ` (${method}${s})` : ""}`;
+  }
+};
+
+// src/ast/select.js
+var SelectClauseNode = class extends SQLNode {
+  /**
+   * Instantiate a select node.
+   * @param {ExprNode} expr The select expression.
+   * @param {string} alias The output name.
+   */
+  constructor(expr, alias) {
+    super(SELECT_CLAUSE);
+    this.expr = expr;
+    this.alias = alias;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { expr, alias } = this;
+    return !alias || isColumnRefFor(expr, alias) ? `${expr}` : `${expr} AS ${quoteIdentifier(alias)}`;
+  }
+};
+function isColumnRefFor(expr, name) {
+  return expr instanceof ColumnRefNode && expr.table == null && expr.column === name;
+}
+
+// src/ast/with.js
+var WithClauseNode = class extends SQLNode {
+  /**
+   * Instantiate a with clause node for a common table expression (CTE).
+   * @param {string} name The common table expression (CTE) name.
+   * @param {Query} query The common table expression (CTE) query.
+   */
+  constructor(name, query) {
+    super(WITH_CLAUSE);
+    this.name = name;
+    this.query = query;
+  }
+  toString() {
+    return `"${this.name}" AS (${this.query})`;
+  }
+};
+
+// src/ast/query.js
+function isQuery(value) {
+  return value instanceof Query;
+}
+function isSelectQuery(value) {
+  return value instanceof SelectQuery;
+}
+function isDescribeQuery(value) {
+  return value instanceof DescribeQuery;
+}
+var Query = class extends ExprNode {
+  /**
+   * Create a new select query with the given SELECT expressions.
+   * @param {...import('../types.js').SelectExpr} expr The SELECT expressions.
+   * @returns {SelectQuery}
+   */
+  static select(...expr) {
+    return new SelectQuery().select(...expr);
+  }
+  /**
+   * Create a new select query with the given FROM expressions.
+   * @param {...import('../types.js').FromExpr} expr The FROM expressions.
+   * @returns {SelectQuery}
+   */
+  static from(...expr) {
+    return new SelectQuery().from(...expr);
+  }
+  /**
+   * Create a new select query with the given WITH CTE queries.
+   * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
+   * @returns {SelectQuery}
+   */
+  static with(...expr) {
+    return new SelectQuery().with(...expr);
+  }
+  /**
+   * Create a new UNION set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  static union(...queries) {
+    return new SetOperation("UNION", queries.flat());
+  }
+  /**
+   * Create a new UNION ALL set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  static unionAll(...queries) {
+    return new SetOperation("UNION ALL", queries.flat());
+  }
+  /**
+   * Create a new INTERSECT set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  static intersect(...queries) {
+    return new SetOperation("INTERSECT", queries.flat());
+  }
+  /**
+   * Create a new EXCEPT set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  static except(...queries) {
+    return new SetOperation("EXCEPT", queries.flat());
+  }
+  /**
+   * Create a new describe query for the given input query.
+   * @param {Query} query The query to describe.
+   * @returns {DescribeQuery}
+   */
+  static describe(query) {
+    return new DescribeQuery(query);
+  }
+  /**
+   * Instantiate a new query.
+   */
+  constructor(type) {
+    super(type);
+    this._orderby = [];
+    this._limit = void 0;
+    this._offset = void 0;
+    this.cteFor = null;
+  }
+  /**
+   * Return a list of subqueries.
+   * @returns {Query[]}
+   */
+  get subqueries() {
+    return [];
+  }
+  /**
+   * Clone this query.
+   * @returns {Query}
+   */
+  clone() {
+    return this;
+  }
+  /**
+   * Add ORDER BY expressions.
+   * @param  {...import('../types.js').OrderByExpr} expr Expressions to add.
+   * @returns
+   */
+  orderby(...expr) {
+    this._orderby = this._orderby.concat(exprList(expr));
+    return this;
+  }
+  /**
+   * Set the query result LIMIT.
+   * @param {number} value The limit value.
+   * @returns {this}
+   */
+  limit(value) {
+    this._limit = Number.isFinite(value) ? value : void 0;
+    return this;
+  }
+  /**
+   * Set the query result OFFSET.
+   * @param {number} value The offset value.
+   * @returns {this}
+   */
+  offset(value) {
+    this._offset = Number.isFinite(value) ? value : void 0;
+    return this;
+  }
+};
+var SelectQuery = class _SelectQuery extends Query {
+  /**
+   * Instantiate a new select query.
+   */
+  constructor() {
+    super(SELECT_QUERY);
+    this._with = [];
+    this._select = [];
+    this._from = [];
+    this._where = [];
+    this._sample = void 0;
+    this._groupby = [];
+    this._having = [];
+    this._window = [];
+    this._qualify = [];
+  }
+  /**
+   * Return a list of subqueries.
+   * @returns {Query[]}
+   */
+  get subqueries() {
+    const q = this.cteFor || this;
+    const w = q instanceof _SelectQuery ? q._with : [];
+    const cte = w.reduce((obj, c) => (obj[c.name] = c.query, obj), {});
+    const queries = [];
+    this._from.forEach(({ expr }) => {
+      if (isQuery(expr)) {
+        queries.push(expr);
+      } else if (isTableRef(expr)) {
+        const subq = cte[expr.name];
+        if (subq) queries.push(subq);
+      }
+    });
+    return queries;
+  }
+  /**
+   * Clone this query.
+   * @returns {SelectQuery}
+   */
+  clone() {
+    return Object.assign(new _SelectQuery(), this);
+  }
+  /**
+   * Add WITH common table expressions (CTEs).
+   * @param  {...import('../types.js').WithExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  with(...expr) {
+    const list = [];
+    const add2 = (name, q) => {
+      const query = q.clone();
+      query.cteFor = this;
+      list.push(new WithClauseNode(name, query));
+    };
+    expr.flat().forEach((e) => {
+      if (e != null) for (const name in e) add2(name, e[name]);
+    });
+    this._with = this._with.concat(list);
+    return this;
+  }
+  /**
+   * Add SELECT expressions.
+   * @param {...import('../types.js').SelectExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  select(...expr) {
+    const list = [];
+    const add2 = (v, as) => list.push(
+      new SelectClauseNode(v == null ? v : asNode(v), unquote(as))
     );
-    sql2.push(`SELECT${distinct ? " DISTINCT" : ""} ${sels.join(", ")}`);
-    if (from.length) {
-      const rels = from.map(({ as, from: from2 }) => {
-        const rel = isQuery(from2) ? `(${from2})` : `${from2}`;
-        return !as || as === from2.table ? rel : `${rel} AS "${as}"`;
-      });
-      sql2.push(`FROM ${rels.join(", ")}`);
+    expr.flat().forEach((e) => {
+      if (e == null) return;
+      else if (isString(e)) add2(e, e);
+      else if (isColumnRef(e)) add2(e, e.column);
+      else if (isArray(e)) add2(e[1], e[0]);
+      else for (const alias in e) add2(e[alias], alias);
+    });
+    const keys = new Set(list.map((x2) => x2.alias));
+    this._select = this._select.filter((x2) => !keys.has(x2.alias)).concat(list.filter((x2) => x2.expr));
+    return this;
+  }
+  /**
+   * Set SELECT expressions, replacing any prior expressions.
+   * @param {...import('../types.js').SelectExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  setSelect(...expr) {
+    this._select = [];
+    return this.select(...expr);
+  }
+  /**
+   * Indicate if this query should retrieve distinct values only.
+   * @param {boolean} value The distinct flag
+   * @returns {this}
+   */
+  distinct(value = true) {
+    this._distinct = !!value;
+    return this;
+  }
+  /**
+   * Add table FROM expressions.
+   * @param  {...import('../types.js').FromExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  from(...expr) {
+    const list = [];
+    const add2 = (v, as) => list.push(new FromClauseNode(asTableRef(v), unquote(as)));
+    expr.flat().forEach((e) => {
+      if (e == null) return;
+      else if (isString(e)) add2(e, e);
+      else if (isTableRef(e)) add2(e, e.name);
+      else if (isNode(e)) add2(e);
+      else if (isArray(e)) add2(e[1], e[0]);
+      else for (const alias in e) add2(e[alias], alias);
+    });
+    this._from = this._from.concat(list);
+    return this;
+  }
+  /**
+   * Set FROM expressions, replacing any prior expressions.
+   * @param {...import('../types.js').FromExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  setFrom(...expr) {
+    this._from = [];
+    return this.from(...expr);
+  }
+  /**
+   * Set SAMPLE settings.
+   * @param {number | SampleClauseNode} value Either a sample clause node
+   *  or the sample size as either a row count or percentage.
+   * @param {import('./sample.js').SampleMethod} [method] The sampling method
+   *  to use.
+   * @param {number} [seed] The random seed.
+   * @returns {this}
+   */
+  sample(value, method, seed) {
+    let clause;
+    if (typeof value === "number") {
+      const perc = value > 0 && value < 1;
+      const size = perc ? value * 100 : Math.floor(value);
+      clause = new SampleClauseNode(size, perc, method, seed);
+    } else {
+      clause = value;
     }
-    if (where.length) {
-      const clauses = where.map(String).filter((x2) => x2).join(" AND ");
+    this._sample = clause;
+    return this;
+  }
+  /**
+   * Add WHERE expressions.
+   * @param  {...import('../types.js').FilterExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  where(...expr) {
+    this._where = this._where.concat(exprList(expr, asVerbatim));
+    return this;
+  }
+  /**
+   * Set WHERE expressions, replacing any prior expressions.
+   * @param {...import('../types.js').FilterExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  setWhere(...expr) {
+    this._where = [];
+    return this.where(...expr);
+  }
+  /**
+   * Add GROUP BY expressions.
+   * @param  {...import('../types.js').GroupByExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  groupby(...expr) {
+    this._groupby = this._groupby.concat(exprList(expr));
+    return this;
+  }
+  /**
+   * Set GROUP BY expressions, replacing any prior expressions.
+   * @param {...import('../types.js').GroupByExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  setGroupby(...expr) {
+    this._groupby = [];
+    return this.groupby(...expr);
+  }
+  /**
+   * Add HAVING expressions.
+   * @param {...import('../types.js').FilterExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  having(...expr) {
+    this._having = this._having.concat(exprList(expr, asVerbatim));
+    return this;
+  }
+  /**
+   * Add WINDOW definitions.
+   * @param  {...any} expr Expressions to add.
+   * @returns {this}
+   */
+  window(...expr) {
+    const list = [];
+    expr.flat().forEach((e) => {
+      if (e != null) for (const name in e) {
+        list.push(new WindowClauseNode(unquote(name), e[name]));
+      }
+    });
+    this._window = this._window.concat(list);
+    return this;
+  }
+  /**
+   * Add QUALIFY expressions.
+   * @param {...import('../types.js').FilterExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  qualify(...expr) {
+    this._qualify = this._qualify.concat(exprList(expr, asVerbatim));
+    return this;
+  }
+  /**
+   * Generate a SQL query string.
+   * @returns {string}
+   */
+  toString() {
+    const {
+      _with,
+      _select,
+      _distinct,
+      _from,
+      _sample,
+      _where,
+      _groupby,
+      _having,
+      _window,
+      _qualify,
+      _orderby,
+      _limit,
+      _offset
+    } = this;
+    const sql2 = [];
+    if (_with.length) sql2.push(`WITH ${_with.join(", ")}`);
+    sql2.push(`SELECT${_distinct ? " DISTINCT" : ""} ${_select.join(", ")}`);
+    if (_from.length) sql2.push(`FROM ${_from.join(", ")}`);
+    if (_where.length) {
+      const clauses = _where.map(String).filter((x2) => x2).join(" AND ");
       if (clauses) sql2.push(`WHERE ${clauses}`);
     }
-    if (sample) {
-      const { rows, perc, method, seed } = sample;
-      const size = rows ? `${rows} ROWS` : `${perc} PERCENT`;
-      const how = method ? ` (${method}${seed != null ? `, ${seed}` : ""})` : "";
-      sql2.push(`USING SAMPLE ${size}${how}`);
+    if (_sample) sql2.push(`USING SAMPLE ${_sample}`);
+    if (_groupby.length) {
+      sql2.push(`GROUP BY ${_groupby.join(", ")}`);
     }
-    if (groupby.length) {
-      sql2.push(`GROUP BY ${groupby.join(", ")}`);
-    }
-    if (having.length) {
-      const clauses = having.map(String).filter((x2) => x2).join(" AND ");
+    if (_having.length) {
+      const clauses = _having.map(String).filter((x2) => x2).join(" AND ");
       if (clauses) sql2.push(`HAVING ${clauses}`);
     }
-    if (window.length) {
-      const windows = window.map(({ as, expr }) => `"${as}" AS (${expr})`);
-      sql2.push(`WINDOW ${windows.join(", ")}`);
-    }
-    if (qualify.length) {
-      const clauses = qualify.map(String).filter((x2) => x2).join(" AND ");
+    if (_window.length) sql2.push(`WINDOW ${_window.join(", ")}`);
+    if (_qualify.length) {
+      const clauses = _qualify.map(String).filter((x2) => x2).join(" AND ");
       if (clauses) sql2.push(`QUALIFY ${clauses}`);
     }
-    if (orderby.length) {
-      sql2.push(`ORDER BY ${orderby.join(", ")}`);
-    }
-    if (Number.isFinite(limit)) {
-      sql2.push(`LIMIT ${limit}`);
-    }
-    if (Number.isFinite(offset)) {
-      sql2.push(`OFFSET ${offset}`);
-    }
+    if (_orderby.length) sql2.push(`ORDER BY ${_orderby.join(", ")}`);
+    if (Number.isFinite(_limit)) sql2.push(`LIMIT ${_limit}`);
+    if (Number.isFinite(_offset)) sql2.push(`OFFSET ${_offset}`);
     return sql2.join(" ");
   }
 };
-var SetOperation = class _SetOperation {
+var DescribeQuery = class _DescribeQuery extends SQLNode {
+  /**
+   * Instantiate a describe query.
+   */
+  constructor(query) {
+    super(DESCRIBE_QUERY);
+    this.query = query;
+  }
+  /**
+   * Clone this describe query.
+   * @returns {DescribeQuery}
+   */
+  clone() {
+    return new _DescribeQuery(this.query.clone());
+  }
+  /**
+   * Generate a SQL query string.
+   * @returns {string}
+   */
+  toString() {
+    return `DESCRIBE ${this.query}`;
+  }
+};
+var SetOperation = class _SetOperation extends Query {
+  /**
+   * Instantiate a new set operation instance.
+   * @param {string} op The set operation.
+   * @param {Query[]} queries The subqueries.
+   */
   constructor(op, queries) {
+    super(SET_OPERATION);
     this.op = op;
-    this.queries = queries.map((q) => q.clone());
-    this.query = { orderby: [] };
-    this.cteFor = null;
+    this.queries = queries;
+  }
+  /**
+   * Return a list of subqueries.
+   * @returns {Query[]}
+   */
+  get subqueries() {
+    const { queries, cteFor } = this;
+    if (cteFor) queries.forEach((q) => q.cteFor = cteFor);
+    return queries;
   }
+  /**
+   * Clone this set operation.
+   * @returns {SetOperation}
+   */
   clone() {
-    const q = new _SetOperation(this.op, this.queries);
-    q.query = { ...this.query };
-    return q;
+    const { op, queries, ...rest } = this;
+    return Object.assign(new _SetOperation(op, queries), rest);
   }
-  orderby(...expr) {
-    const { query } = this;
-    if (expr.length === 0) {
-      return query.orderby;
-    } else {
-      query.orderby = query.orderby.concat(
-        expr.flat().filter((x2) => x2).map(asColumn)
-      );
-      return this;
-    }
+  /**
+   * Generate a SQL query string.
+   * @returns {string}
+   */
+  toString() {
+    const { op, queries, _orderby, _limit, _offset } = this;
+    const sql2 = [queries.join(` ${op} `)];
+    if (_orderby.length) sql2.push(`ORDER BY ${_orderby.join(", ")}`);
+    if (Number.isFinite(_limit)) sql2.push(`LIMIT ${_limit}`);
+    if (Number.isFinite(_offset)) sql2.push(`OFFSET ${_offset}`);
+    return sql2.join(" ");
   }
-  limit(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.limit;
+};
+
+// src/ast/from.js
+var FromClauseNode = class extends SQLNode {
+  /**
+   * Instantiate a from node.
+   * @param {SQLNode} expr The from expression.
+   * @param {string} alias The output name.
+   */
+  constructor(expr, alias) {
+    super(FROM_CLAUSE);
+    this.expr = expr;
+    this.alias = alias;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { expr, alias } = this;
+    const ref = isQuery(expr) ? `(${expr})` : `${expr}`;
+    return alias && !(isTableRef(expr) && expr.table.join(".") === alias) ? `${ref} AS ${quoteIdentifier(alias)}` : `${ref}`;
+  }
+};
+
+// src/ast/in-op.js
+var InOpNode = class extends ExprNode {
+  /**
+   * Instantiate an in operator node.
+   * @param {ExprNode} expr The input expression.
+   * @param {ExprNode[]} values The value set.
+   */
+  constructor(expr, values) {
+    super(IN_OPERATOR);
+    this.expr = expr;
+    this.values = values;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.expr} IN (${this.values.join(", ")}))`;
+  }
+};
+
+// src/ast/interval.js
+var IntervalNode = class extends ExprNode {
+  /**
+   * Instantiate an interval node.
+   * @param {string} name The interval name.
+   * @param {number} [steps=1] The interval steps.
+   */
+  constructor(name, steps = 1) {
+    super(INTERVAL);
+    this.name = name;
+    this.steps = steps;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `INTERVAL ${this.steps} ${this.name}`;
+  }
+};
+
+// src/ast/logical-op.js
+var LogicalOpNode = class extends ExprNode {
+  /**
+   * Instantiate a logical operator node.
+   * @param {string} op The logical operation.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(op, clauses) {
+    super(LOGICAL_OPERATOR);
+    this.op = op;
+    this.clauses = clauses;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const c = this.clauses;
+    return c.length === 0 ? "" : c.length === 1 ? `${c[0]}` : `(${c.join(` ${this.op} `)})`;
+  }
+};
+var AndNode = class extends LogicalOpNode {
+  /**
+   * Instantiate a logical AND operator node.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(clauses) {
+    super("AND", clauses);
+  }
+};
+var OrNode = class extends LogicalOpNode {
+  /**
+   * Instantiate a logical OR operator node.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(clauses) {
+    super("OR", clauses);
+  }
+};
+
+// src/ast/order-by.js
+var OrderByNode = class extends ExprNode {
+  /**
+   * Instantiate an order by entry node.
+   * @param {ExprNode} expr The expression to order by.
+   * @param {boolean | undefined} [desc] Flag indicating descending order.
+   * @param {boolean | undefined} [nullsFirst] Flag indicating if null
+   *  values should be sorted first.
+   */
+  constructor(expr, desc2, nullsFirst) {
+    super(ORDER_BY);
+    this.expr = expr;
+    this.desc = desc2;
+    this.nullsFirst = nullsFirst;
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { expr, desc: desc2, nullsFirst } = this;
+    const dir = desc2 ? " DESC" : desc2 === false ? " ASC" : "";
+    const nf = nullsFirst ? " NULLS FIRST" : nullsFirst === false ? " NULLS LAST" : "";
+    return `${expr}${dir}${nf}`;
+  }
+};
+
+// src/ast/unary-op.js
+var AbstractUnaryOpNode = class extends ExprNode {
+  /**
+   * Instantiate an abstract unary operator node.
+   * @param {string} type The node type.
+   * @param {string} op The operator type.
+   * @param {ExprNode} expr The input expression.
+   */
+  constructor(type, op, expr) {
+    super(type);
+    this.op = op;
+    this.expr = expr;
+  }
+};
+var UnaryOpNode = class extends AbstractUnaryOpNode {
+  /**
+   * Instantiate a unary operator node.
+   * @param {string} op The operator type.
+   * @param {ExprNode} expr The input expression.
+   */
+  constructor(op, expr) {
+    super(UNARY_OPERATOR, op, expr);
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.op} ${this.expr})`;
+  }
+};
+var UnaryPosftixOpNode = class extends AbstractUnaryOpNode {
+  /**
+   * Instantiate a unary operator node.
+   * @param {string} op The operator type.
+   * @param {ExprNode} expr The input expression.
+   */
+  constructor(op, expr) {
+    super(UNARY_POSTFIX_OPERATOR, op, expr);
+  }
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.expr} ${this.op})`;
+  }
+};
+
+// src/functions/aggregate.js
+function argmax(y2, x2) {
+  return aggFn("arg_max", y2, x2);
+}
+function argmin(y2, x2) {
+  return aggFn("arg_min", y2, x2);
+}
+function arrayAgg(expr) {
+  return aggFn("array_agg", expr);
+}
+function avg(expr) {
+  return aggFn("avg", expr);
+}
+function corr(x2, y2) {
+  return aggFn("corr", x2, y2);
+}
+function count(expr) {
+  return aggFn("count", expr);
+}
+function covariance(x2, y2) {
+  return aggFn("covar_samp", x2, y2);
+}
+function covarPop(x2, y2) {
+  return aggFn("covar_pop", x2, y2);
+}
+function entropy(expr) {
+  return aggFn("entropy", expr);
+}
+function first(expr) {
+  return aggFn("first", expr);
+}
+function kurtosis(expr) {
+  return aggFn("kurtosis", expr);
+}
+function mad(expr) {
+  return aggFn("mad", expr);
+}
+function max(expr) {
+  return aggFn("max", expr);
+}
+function median(expr) {
+  return aggFn("median", expr);
+}
+function min(expr) {
+  return aggFn("min", expr);
+}
+function mode(expr) {
+  return aggFn("mode", expr);
+}
+function last(expr) {
+  return aggFn("last", expr);
+}
+function product(expr) {
+  return aggFn("product", expr);
+}
+function quantile(expr, p) {
+  return aggFn("quantile", expr, p);
+}
+function regrAvgX(x2, y2) {
+  return aggFn("regr_avgx", x2, y2);
+}
+function regrAvgY(x2, y2) {
+  return aggFn("regr_avgy", x2, y2);
+}
+function regrCount(x2, y2) {
+  return aggFn("regr_count", x2, y2);
+}
+function regrIntercept(x2, y2) {
+  return aggFn("regr_intercept", x2, y2);
+}
+function regrR2(x2, y2) {
+  return aggFn("regr_r2", x2, y2);
+}
+function regrSXX(x2, y2) {
+  return aggFn("regr_sxx", x2, y2);
+}
+function regrSXY(x2, y2) {
+  return aggFn("regr_sxy", x2, y2);
+}
+function regrSYY(x2, y2) {
+  return aggFn("regr_syy", x2, y2);
+}
+function regrSlope(x2, y2) {
+  return aggFn("regr_slope", x2, y2);
+}
+function skewness(expr) {
+  return aggFn("skewness", expr);
+}
+function stddev(expr) {
+  return aggFn("stddev", expr);
+}
+function stddevPop(expr) {
+  return aggFn("stddev_pop", expr);
+}
+function stringAgg(expr) {
+  return aggFn("string_agg", expr);
+}
+function sum(expr) {
+  return aggFn("sum", expr);
+}
+function variance(expr) {
+  return aggFn("var_samp", expr);
+}
+function varPop(expr) {
+  return aggFn("var_pop", expr);
+}
+
+// src/functions/case.js
+function cond(when, then, other) {
+  return when ? new CaseNode(void 0, [new WhenNode(asNode(when), asNode(then))], asNode(other)) : new CaseNode();
+}
+
+// src/functions/cast.js
+function cast(expr, type) {
+  return new CastNode(asNode(expr), type);
+}
+function int32(expr) {
+  return cast(expr, "INTEGER");
+}
+function float32(expr) {
+  return cast(expr, "FLOAT");
+}
+function float64(expr) {
+  return cast(expr, "DOUBLE");
+}
+
+// src/functions/datetime.js
+function interval(unit, steps) {
+  return new IntervalNode(unit, steps);
+}
+function epoch_ms(expr) {
+  return fn("epoch_ms", expr);
+}
+function dateBin(expr, unit, steps = 1) {
+  return fn("time_bucket", interval(unit, steps), expr);
+}
+function dateMonth(expr) {
+  return fn("make_date", 2012, fn("month", expr), 1);
+}
+function dateMonthDay(expr) {
+  const d = asNode(expr);
+  return fn("make_date", 2012, fn("month", d), fn("day", d));
+}
+function dateDay(expr) {
+  return fn("make_date", 2012, 1, fn("day", expr));
+}
+
+// src/functions/numeric.js
+function isNaN(expr) {
+  return fn("isnan", expr);
+}
+function isFinite(expr) {
+  return fn("isfinite", expr);
+}
+function isInfinite(expr) {
+  return fn("isinf", expr);
+}
+function greatest(...expr) {
+  return fn("greatest", ...expr);
+}
+function least(...expr) {
+  return fn("least", ...expr);
+}
+function exp(expr) {
+  return fn("exp", expr);
+}
+function log(expr) {
+  return fn("log", expr);
+}
+function ln(expr) {
+  return fn("ln", expr);
+}
+function sign(expr) {
+  return fn("sign", expr);
+}
+function abs(expr) {
+  return fn("abs", expr);
+}
+function sqrt(expr) {
+  return fn("sqrt", expr);
+}
+function ceil(expr) {
+  return fn("ceil", expr);
+}
+function floor(expr) {
+  return fn("floor", expr);
+}
+function round(expr, places) {
+  return fn("round", expr, places);
+}
+function trunc(expr) {
+  return fn("trunc", expr);
+}
+
+// src/functions/operators.js
+function unaryOp(op, expr) {
+  return new UnaryOpNode(op, asNode(expr));
+}
+function unaryPostfixOp(op, expr) {
+  return new UnaryPosftixOpNode(op, asNode(expr));
+}
+function binaryOp(op, left, right) {
+  return new BinaryOpNode(op, asNode(left), asNode(right));
+}
+function betweenOp(expr, extent, negate = false) {
+  const Op = negate ? NotBetweenOpNode : BetweenOpNode;
+  return new Op(asNode(expr), extent?.map(asNode));
+}
+function and(...clauses) {
+  return new AndNode(exprList(clauses));
+}
+function or(...clauses) {
+  return new OrNode(exprList(clauses));
+}
+function not(expr) {
+  return unaryOp("NOT", expr);
+}
+function isNull(expr) {
+  return unaryPostfixOp("IS NULL", expr);
+}
+function isNotNull(expr) {
+  return unaryPostfixOp("IS NOT NULL", expr);
+}
+function bitNot(expr) {
+  return unaryOp("~", expr);
+}
+function bitAnd(left, right) {
+  return binaryOp("&", left, right);
+}
+function bitOr(left, right) {
+  return binaryOp("|", left, right);
+}
+function bitLeft(left, right) {
+  return binaryOp("<<", left, right);
+}
+function bitRight(left, right) {
+  return binaryOp(">>", left, right);
+}
+function add(left, right) {
+  return binaryOp("+", left, right);
+}
+function sub(left, right) {
+  return binaryOp("-", left, right);
+}
+function mul(left, right) {
+  return binaryOp("*", left, right);
+}
+function div(left, right) {
+  return binaryOp("/", left, right);
+}
+function idiv(left, right) {
+  return binaryOp("//", left, right);
+}
+function mod(left, right) {
+  return binaryOp("%", left, right);
+}
+function pow(left, right) {
+  return binaryOp("**", left, right);
+}
+function eq(left, right) {
+  return binaryOp("=", left, right);
+}
+function neq(left, right) {
+  return binaryOp("<>", left, right);
+}
+function lt(left, right) {
+  return binaryOp("<", left, right);
+}
+function gt(left, right) {
+  return binaryOp(">", left, right);
+}
+function lte(left, right) {
+  return binaryOp("<=", left, right);
+}
+function gte(left, right) {
+  return binaryOp(">=", left, right);
+}
+function isDistinct(left, right) {
+  return binaryOp("IS DISTINCT FROM", left, right);
+}
+function isNotDistinct(left, right) {
+  return binaryOp("IS NOT DISTINCT FROM", left, right);
+}
+function isBetween(expr, extent) {
+  return betweenOp(expr, extent, false);
+}
+function isNotBetween(expr, extent) {
+  return betweenOp(expr, extent, true);
+}
+function isIn(expr, values) {
+  return new InOpNode(asNode(expr), values.map(asNode));
+}
+
+// src/functions/order-by.js
+function asc(expr, nullsFirst) {
+  return new OrderByNode(asNode(expr), false, nullsFirst);
+}
+function desc(expr, nullsFirst) {
+  return new OrderByNode(asNode(expr), true, nullsFirst);
+}
+
+// src/functions/spatial.js
+function geojson(expr) {
+  return fn("st_asgeojson", expr);
+}
+function x(expr) {
+  return fn("st_x", expr);
+}
+function y(expr) {
+  return fn("st_y", expr);
+}
+function centroid(expr) {
+  return fn("st_centroid", expr);
+}
+function centroidX(expr) {
+  return x(centroid(expr));
+}
+function centroidY(expr) {
+  return y(centroid(expr));
+}
+
+// src/functions/sql-template-tag.js
+function sql(strings, ...exprs) {
+  return new FragmentNode(parseSQL(strings, exprs));
+}
+function parseSQL(strings, exprs) {
+  const spans = [strings[0]];
+  const n = exprs.length;
+  for (let i = 0, k = 0; i < n; ) {
+    const e = exprs[i];
+    if (isNode(e)) {
+      spans[++k] = e;
+    } else if (isParamLike(e)) {
+      spans[++k] = new ParamNode(e);
     } else {
-      query.limit = Number.isFinite(value) ? value : void 0;
-      return this;
+      spans[k] += isString(e) ? e : literal(e);
     }
-  }
-  offset(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.offset;
+    const s = strings[++i];
+    if (isNode(spans[k])) {
+      spans[++k] = s;
     } else {
-      query.offset = Number.isFinite(value) ? value : void 0;
-      return this;
-    }
-  }
-  get subqueries() {
-    const { queries, cteFor } = this;
-    if (cteFor) queries.forEach((q) => q.cteFor = cteFor);
-    return queries;
-  }
-  toString() {
-    const { op, queries, query: { orderby, limit, offset } } = this;
-    const sql2 = [queries.join(` ${op} `)];
-    if (orderby.length) {
-      sql2.push(`ORDER BY ${orderby.join(", ")}`);
-    }
-    if (Number.isFinite(limit)) {
-      sql2.push(`LIMIT ${limit}`);
-    }
-    if (Number.isFinite(offset)) {
-      sql2.push(`OFFSET ${offset}`);
+      spans[k] += s;
     }
-    return sql2.join(" ");
   }
-};
-function isQuery(value) {
-  return value instanceof Query || value instanceof SetOperation;
+  return spans.filter((s) => s).map((s) => isString(s) ? new VerbatimNode(s) : s);
 }
-function isDescribeQuery(value) {
-  return isQuery(value) && value.describe;
+
+// src/functions/string.js
+function strFn(name, expr, ...args) {
+  return fn(name, expr, ...argsList(args).map(asLiteral));
 }
-function unquote(s) {
-  return isDoubleQuoted(s) ? s.slice(1, -1) : s;
+function regexp_matches(string, pattern, options) {
+  return strFn("regexp_matches", string, pattern, options);
 }
-function isDoubleQuoted(s) {
-  return s[0] === '"' && s[s.length - 1] === '"';
+function contains(string, search_string) {
+  return strFn("contains", string, search_string);
+}
+function prefix(string, search_string) {
+  return strFn("starts_with", string, search_string);
+}
+function suffix(string, search_string) {
+  return strFn("ends_with", string, search_string);
+}
+function lower(string) {
+  return strFn("lower", string);
+}
+function upper(string) {
+  return strFn("upper", string);
+}
+function length(value) {
+  return strFn("length", value);
 }
 
-// src/scales.js
-var identity = (x2) => x2;
-function scaleLinear() {
-  return {
-    apply: identity,
-    invert: identity,
-    sqlApply: asColumn,
-    sqlInvert: identity
-  };
+// src/functions/window.js
+function row_number() {
+  return winFn("row_number");
 }
-function scaleLog({ base = null } = {}) {
-  if (base == null || base === Math.E) {
-    return {
-      apply: Math.log,
-      invert: Math.exp,
-      sqlApply: (c) => sql`LN(${asColumn(c)})`,
-      sqlInvert: (c) => sql`EXP(${c})`
-    };
-  } else if (base === 10) {
-    return {
-      apply: Math.log10,
-      invert: (x2) => Math.pow(10, x2),
-      sqlApply: (c) => sql`LOG(${asColumn(c)})`,
-      sqlInvert: (c) => sql`POW(10, ${c})`
-    };
-  } else {
-    const b = +base;
-    return {
-      apply: (x2) => Math.log(x2) / Math.log(b),
-      invert: (x2) => Math.pow(b, x2),
-      sqlApply: (c) => sql`LN(${asColumn(c)}) / LN(${b})`,
-      sqlInvert: (c) => sql`POW(${b}, ${c})`
-    };
-  }
+function rank() {
+  return winFn("rank");
 }
-function scaleSymlog({ constant = 1 } = {}) {
-  const _ = +constant;
-  return {
-    apply: (x2) => Math.sign(x2) * Math.log1p(Math.abs(x2)),
-    invert: (x2) => Math.sign(x2) * Math.exp(Math.abs(x2) - _),
-    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * LN(${_} + ABS(${c}))`),
-    sqlInvert: (c) => sql`SIGN(${c}) * (EXP(ABS(${c})) - ${_})`
-  };
+function dense_rank() {
+  return winFn("dense_rank");
 }
-function scaleSqrt() {
-  return {
-    apply: (x2) => Math.sign(x2) * Math.sqrt(Math.abs(x2)),
-    invert: (x2) => Math.sign(x2) * x2 * x2,
-    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * SQRT(ABS(${c}))`),
-    sqlInvert: (c) => sql`SIGN(${c}) * (${c}) ** 2`
-  };
+function percent_rank() {
+  return winFn("percent_rank");
 }
-function scalePow({ exponent = 1 } = {}) {
-  const e = +exponent;
-  return {
-    apply: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), e),
-    invert: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), 1 / e),
-    sqlApply: (c) => (c = asColumn(c), sql`SIGN(${c}) * POW(ABS(${c}), ${e})`),
-    sqlInvert: (c) => sql`SIGN(${c}) * POW(ABS(${c}), 1/${e})`
-  };
+function cume_dist() {
+  return winFn("cume_dist");
 }
-function scaleTime() {
-  return {
-    apply: (x2) => +x2,
-    invert: (x2) => new Date(x2),
-    sqlApply: (c) => c instanceof Date ? +c : epoch_ms(asColumn(c)),
-    sqlInvert: identity
-  };
+function ntile(num_buckets) {
+  return winFn("ntile", num_buckets);
 }
-var scales = {
-  identity: scaleLinear,
-  linear: scaleLinear,
-  log: scaleLog,
-  symlog: scaleSymlog,
-  sqrt: scaleSqrt,
-  pow: scalePow,
-  time: scaleTime,
-  utc: scaleTime
+function lag(expr, offset, defaultValue) {
+  return winFn("lag", expr, offset, defaultValue);
+}
+function lead(expr, offset, defaultValue) {
+  return winFn("lead", expr, offset, defaultValue);
+}
+function first_value(expr) {
+  return winFn("first_value", expr);
+}
+function last_value(expr) {
+  return winFn("last_value", expr);
+}
+function nth_value(expr, nth) {
+  return winFn("nth_value", expr, nth);
+}
+
+// src/visit/recurse.js
+var recurse = {
+  [AGGREGATE]: ["args", "filter"],
+  [BETWEEN_OPERATOR]: ["expr", "extent"],
+  [BINARY_OPERATOR]: ["left", "right"],
+  [CASE]: ["expr", "_when", "_else"],
+  [CAST]: ["expr"],
+  [COLUMN_PARAM]: ["param", "table"],
+  [COLUMN_REF]: ["table"],
+  [DESCRIBE_QUERY]: ["query"],
+  [EXPRESSION]: ["node"],
+  [FRAGMENT]: ["spans"],
+  [FROM_CLAUSE]: ["expr"],
+  [FUNCTION]: ["args"],
+  [IN_OPERATOR]: ["expr", "values"],
+  [LOGICAL_OPERATOR]: ["clauses"],
+  [NOT_BETWEEN_OPERATOR]: ["expr", "extent"],
+  [ORDER_BY]: ["expr"],
+  [PARAM]: ["value"],
+  [SELECT_CLAUSE]: ["expr"],
+  [SELECT_QUERY]: ["_with", "_select", "_from", "_where", "_sample", "_groupby", "_having", "_window", "_qualify", "_orderby"],
+  [SET_OPERATION]: ["subqueries", "_orderby"],
+  [UNARY_OPERATOR]: ["expr"],
+  [WHEN]: ["when", "then"],
+  [WINDOW]: ["func", "def"],
+  [WINDOW_CLAUSE]: ["def"],
+  [WINDOW_DEF]: ["partition", "order", "frame"],
+  [WINDOW_FRAME]: ["extent"]
 };
-function scaleTransform(options) {
-  const scale = scales[options.type];
-  return scale ? { ...options, ...scale(options) } : null;
+
+// src/visit/rewrite.js
+function rewrite(node, map) {
+  if (map.has(node)) {
+    return map.get(node);
+  } else if (isNode(node)) {
+    const props = recurse[node.type];
+    const n = props?.length ?? 0;
+    for (let i = 0; i < n; ++i) {
+      const prop = props[i];
+      const child = node[prop];
+      if (Array.isArray(child)) {
+        const m = child.length;
+        for (let j = 0; j < m; ++j) {
+          child[j] = rewrite(child[j], map);
+        }
+      } else if (child) {
+        node[prop] = rewrite(child, map);
+      }
+    }
+  }
+  return node;
+}
+
+// src/visit/walk.js
+function walk(node, visit) {
+  if (!isNode(node)) return;
+  const result = visit(node);
+  if (result) return result;
+  const props = recurse[node.type];
+  const n = props?.length ?? 0;
+  for (let i = 0; i < n; ++i) {
+    const value = node[props[i]];
+    if (Array.isArray(value)) {
+      const m = value.length;
+      for (let j = 0; j < m; ++j) {
+        if (value[j] && +walk(value[j], visit) < 0) {
+          return result;
+        }
+      }
+    } else if (value && +walk(value, visit) < 0) {
+      return -1;
+    }
+  }
+}
+
+// src/visit/visitors.js
+var aggrRegExp = new RegExp(`^(${aggregateNames.join("|")})$`);
+var funcRegExp = /(\\'|\\"|"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|\w+\()/g;
+function hasVerbatimAggregate(s) {
+  return s.split(funcRegExp).some((tok) => tok.endsWith("(") && aggrRegExp.test(tok.slice(0, -1)));
+}
+function isAggregateExpression(root) {
+  let agg = 0;
+  walk(root, (node) => {
+    switch (node.type) {
+      case WINDOW:
+        return -1;
+      // aggs can't include windows
+      case AGGREGATE:
+        agg |= 1;
+        return -1;
+      case FRAGMENT:
+      case VERBATIM: {
+        let s = `${node}`.toLowerCase();
+        const sub2 = s.indexOf("(select ");
+        if (sub2 >= 0) s = s.slice(0, sub2);
+        if (s.includes(") over ")) return -1;
+        if (hasVerbatimAggregate(s)) {
+          agg |= 2;
+          return -1;
+        }
+        return 1;
+      }
+    }
+  });
+  return agg;
+}
+function collectAggregates(root) {
+  const aggs = /* @__PURE__ */ new Set();
+  walk(root, (node) => {
+    if (node.type === AGGREGATE) {
+      aggs.add(node);
+    }
+  });
+  return Array.from(aggs);
+}
+function collectColumns(root) {
+  const cols = {};
+  walk(root, (node) => {
+    if (node.type === COLUMN_REF) {
+      cols[node] = node;
+    }
+  });
+  return Object.values(cols);
+}
+function collectParams(root) {
+  const params = /* @__PURE__ */ new Set();
+  walk(root, (node) => {
+    if (node.type === PARAM) {
+      params.add(
+        /** @type {import('../ast/param.js').ParamNode} */
+        node.param
+      );
+    }
+  });
+  return Array.from(params);
 }
 
 // src/load/create.js
-function create(name, query, {
+function createTable(name, query, {
   replace = false,
-  temp = true,
+  temp = false,
   view = false
 } = {}) {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
+function createSchema(name, {
+  strict = false
+} = {}) {
+  return "CREATE SCHEMA " + (strict ? "" : "IF NOT EXISTS ") + name;
+}
 
 // src/load/extension.js
 function loadExtension(name) {
@@ -1252,7 +2153,7 @@ function sqlFrom(data, {
   }
   const subq = [];
   for (const datum of data) {
-    const sel = keys.map((k) => `${literalToSQL(datum[k])} AS "${columns[k]}"`);
+    const sel = keys.map((k) => `${asLiteral(datum[k])} AS "${columns[k]}"`);
     subq.push(`(SELECT ${sel.join(", ")})`);
   }
   return subq.join(" UNION ALL ");
@@ -1265,13 +2166,13 @@ function load(method, tableName, fileName, options = {}, defaults = {}) {
   const read = `${method}('${fileName}'${params ? ", " + params : ""})`;
   const filter = where ? ` WHERE ${where}` : "";
   const query = `SELECT ${select.join(", ")} FROM ${read}${filter}`;
-  return create(tableName, query, { view, temp, replace });
+  return createTable(tableName, query, { view, temp, replace });
 }
 function loadCSV(tableName, fileName, options) {
   return load("read_csv", tableName, fileName, options, { auto_detect: true, sample_size: -1 });
 }
 function loadJSON(tableName, fileName, options) {
-  return load("read_json", tableName, fileName, options, { auto_detect: true, json_format: "auto" });
+  return load("read_json", tableName, fileName, options, { auto_detect: true, format: "auto" });
 }
 function loadParquet(tableName, fileName, options) {
   return load("read_parquet", tableName, fileName, options);
@@ -1288,7 +2189,7 @@ function loadObjects(tableName, data, options = {}) {
   const { select = ["*"], ...opt } = options;
   const values = sqlFrom(data);
   const query = select.length === 1 && select[0] === "*" ? values : `SELECT ${select} FROM ${values}`;
-  return create(tableName, query, opt);
+  return createTable(tableName, query, opt);
 }
 function parameters(options) {
   return Object.entries(options).map(([key, value]) => `${key}=${toDuckDBValue(value)}`).join(", ");
@@ -1312,32 +2213,283 @@ function toDuckDBValue(value) {
       return value;
   }
 }
+
+// src/transforms/bin-1d.js
+function bin1d(x2, lo, hi, bins, reverse) {
+  const diff = reverse ? sub(hi, float64(x2)) : sub(float64(x2), lo);
+  const scale = hi === lo ? 0 : bins / (hi - lo);
+  return scale ? mul(diff, float64(scale)) : diff;
+}
+
+// src/transforms/bin-2d.js
+function bin2d(q, xp, yp, aggs, xn, groupby) {
+  return q.select({
+    index: add(int32(floor(xp)), mul(int32(floor(yp)), xn)),
+    ...aggs
+  }).groupby("index", groupby);
+}
+
+// src/transforms/bin-linear-1d.js
+function binLinear1d(query, x2, weight) {
+  const w = weight ? (x3) => mul(x3, weight) : (x3) => x3;
+  const p0 = floor(x2);
+  const p1 = add(p0, 1);
+  return Query.from(Query.unionAll(
+    query.clone().select({ i: int32(p0), w: w(sub(p1, x2)) }),
+    query.clone().select({ i: int32(p1), w: w(sub(x2, p0)) })
+  )).select({ index: "i", density: sum("w") }).groupby("index").having(neq("density", 0));
+}
+
+// src/transforms/bin-linear-2d.js
+function identity(x2) {
+  return x2;
+}
+function binLinear2d(q, xp, yp, weight, xn, groupby) {
+  const w = weight ? (x2) => mul(x2, weight) : identity;
+  const subq = (i, w2) => q.clone().select({ xp, yp, i, w: w2 });
+  const index = (x2, y2) => add(x2, mul(y2, xn));
+  const xu = int32(floor(xp));
+  const yu = int32(floor(yp));
+  const xv = add(xu, 1);
+  const yv = add(yu, 1);
+  const xpu = sub(xp, xu);
+  const xvp = sub(xv, xp);
+  const ypu = sub(yp, yu);
+  const yvp = sub(yv, yp);
+  return Query.from(Query.unionAll(
+    // grid[xu + yu * xn] += (xv - xp) * (yv - yp) * wi
+    subq(index(xu, yu), w(mul(xvp, yvp))),
+    // grid[xu + yv * xn] += (xv - xp) * (yp - yu) * wi
+    subq(index(xu, yv), w(mul(xvp, ypu))),
+    // grid[xv + yu * xn] += (xp - xu) * (yv - yp) * wi
+    subq(index(xv, yu), w(mul(xpu, yvp))),
+    // grid[xv + yv * xn] += (xp - xu) * (yp - yu) * wi
+    subq(index(xv, yv), w(mul(xpu, ypu)))
+  )).select({ index: "i", density: sum("w") }, groupby).groupby("index", groupby).having(neq("density", 0));
+}
+
+// src/transforms/line-density.js
+function lineDensity(q, x2, y2, z, xn, yn, groupby = [], normalize = true) {
+  q.select({
+    x: int32(floor(x2)),
+    y: int32(floor(y2))
+  });
+  const groups = groupby.concat(z);
+  const pairs = Query.from(q).select(groups, {
+    x0: "x",
+    y0: "y",
+    dx: sub(lead("x").over("sw"), "x"),
+    dy: sub(lead("y").over("sw"), "y")
+  }).window({
+    sw: over().partitionby(groups).orderby(asc("x"))
+  }).qualify([
+    or(lt("x0", xn), lt(add("x0", "dx"), xn)),
+    or(lt("y0", yn), lt(add("y0", "dy"), yn)),
+    or(gt("x0", 0), gt(add("x0", "dx"), 0)),
+    or(gt("y0", 0), gt(add("y0", "dy"), 0))
+  ]);
+  const num = Query.select({ x: greatest(max(abs("dx")), max(abs("dy"))) }).from("pairs");
+  const indices = Query.select({
+    i: int32(sql`UNNEST(range((${num})))`)
+  });
+  const raster = Query.unionAll(
+    Query.select(groups, {
+      x: add("x0", "i"),
+      y: add("y0", int32(round(div(mul("i", "dy"), "dx"))))
+    }).from("pairs", "indices").where([lte(abs("dy"), abs("dx")), lt("i", abs("dx"))]),
+    Query.select(groups, {
+      x: add("x0", int32(round(div(mul(mul(sign("dy"), "i"), "dx"), "dy")))),
+      y: add("y0", mul(sign("dy"), "i"))
+    }).from("pairs", "indices").where([gt(abs("dy"), abs("dx")), lt("i", abs("dy"))]),
+    Query.select(groups, { x: "x0", y: "y0" }).from("pairs").where(isNull("dx"))
+  );
+  const points = Query.from("raster").select(
+    groups,
+    "x",
+    "y",
+    normalize ? { w: div(1, count().partitionby(["x"].concat(groups))) } : null
+  ).where([lte(0, "x"), lt("x", xn), lte(0, "y"), lt("y", yn)]);
+  return Query.with({ pairs, indices, raster, points }).from("points").select(groupby, {
+    index: add("x", mul("y", int32(xn))),
+    density: normalize ? sum("w") : count()
+  }).groupby("index", groupby);
+}
+
+// src/transforms/m4.js
+function m4(input, bin, x2, y2, groups = []) {
+  const pixel = int32(floor(bin));
+  const q = (sel) => Query.from(input).select(sel).groupby(pixel, groups);
+  return Query.union(
+    q([{ [x2]: min(x2), [y2]: argmin(y2, x2) }, ...groups]),
+    q([{ [x2]: max(x2), [y2]: argmax(y2, x2) }, ...groups]),
+    q([{ [x2]: argmin(x2, y2), [y2]: min(y2) }, ...groups]),
+    q([{ [x2]: argmax(x2, y2), [y2]: max(y2) }, ...groups])
+  ).orderby(groups, x2);
+}
+
+// src/transforms/scales.js
+var identity2 = (x2) => x2;
+function scaleLinear() {
+  return {
+    apply: identity2,
+    invert: identity2,
+    sqlApply: asNode,
+    sqlInvert: identity2
+  };
+}
+function scaleLog({ base = null } = {}) {
+  if (base == null || base === Math.E) {
+    return {
+      apply: Math.log,
+      invert: Math.exp,
+      sqlApply: (c) => ln(c),
+      sqlInvert: (c) => exp(c)
+    };
+  } else if (base === 10) {
+    return {
+      apply: Math.log10,
+      invert: (x2) => Math.pow(10, x2),
+      sqlApply: (c) => log(c),
+      sqlInvert: (c) => pow(10, c)
+    };
+  } else {
+    const b = +base;
+    return {
+      apply: (x2) => Math.log(x2) / Math.log(b),
+      invert: (x2) => Math.pow(b, x2),
+      sqlApply: (c) => div(ln(c), ln(b)),
+      sqlInvert: (c) => pow(b, c)
+    };
+  }
+}
+function scaleSymlog({ constant = 1 } = {}) {
+  const _ = +constant;
+  return {
+    apply: (x2) => Math.sign(x2) * Math.log1p(Math.abs(x2)),
+    invert: (x2) => Math.sign(x2) * Math.exp(Math.abs(x2) - _),
+    sqlApply: (c) => (c = asNode(c), mul(sign(c), ln(add(_, abs(c))))),
+    sqlInvert: (c) => mul(sign(c), sub(exp(abs(c)), _))
+  };
+}
+function scaleSqrt() {
+  return {
+    apply: (x2) => Math.sign(x2) * Math.sqrt(Math.abs(x2)),
+    invert: (x2) => Math.sign(x2) * x2 * x2,
+    sqlApply: (c) => (c = asNode(c), mul(sign(c), sqrt(abs(c)))),
+    sqlInvert: (c) => mul(sign(c), pow(c, 2))
+  };
+}
+function scalePow({ exponent = 1 } = {}) {
+  const e = +exponent;
+  return {
+    apply: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), e),
+    invert: (x2) => Math.sign(x2) * Math.pow(Math.abs(x2), 1 / e),
+    sqlApply: (c) => (c = asNode(c), mul(sign(c), pow(abs(c), e))),
+    sqlInvert: (c) => mul(sign(c), pow(abs(c), div(1, e)))
+  };
+}
+function scaleTime() {
+  return {
+    apply: (x2) => +x2,
+    invert: (x2) => new Date(x2),
+    sqlApply: (c) => c instanceof Date ? literal(+c) : isDateLiteral(c) ? literal(+c.value) : epoch_ms(c),
+    sqlInvert: identity2
+  };
+}
+var scales = {
+  identity: scaleLinear,
+  linear: scaleLinear,
+  log: scaleLog,
+  symlog: scaleSymlog,
+  sqrt: scaleSqrt,
+  pow: scalePow,
+  time: scaleTime,
+  utc: scaleTime
+};
+function scaleTransform(options) {
+  const scale = scales[options.type];
+  return scale ? { ...options, ...scale(options) } : null;
+}
+function isDateLiteral(x2) {
+  return x2 instanceof LiteralNode && x2.value instanceof Date;
+}
 export {
+  AggregateNode,
+  AndNode,
+  BetweenOpNode,
+  BinaryOpNode,
+  CaseNode,
+  CastNode,
+  ColumnNameRefNode,
+  ColumnParamNode,
+  ColumnRefNode,
+  DescribeQuery,
+  ExprNode,
+  FragmentNode,
+  FromClauseNode,
+  FunctionNode,
+  InOpNode,
+  IntervalNode,
+  LiteralNode,
+  NotBetweenOpNode,
+  OrNode,
+  OrderByNode,
+  ParamNode,
   Query,
-  Ref,
-  SQLExpression,
-  agg,
-  all,
+  SQLNode,
+  SampleClauseNode,
+  SelectClauseNode,
+  SelectQuery,
+  SetOperation,
+  TableRefNode,
+  UnaryOpNode,
+  UnaryPosftixOpNode,
+  VerbatimNode,
+  WhenNode,
+  WindowClauseNode,
+  WindowDefNode,
+  WindowFrameNode,
+  WindowFunctionNode,
+  WindowNode,
+  WithClauseNode,
+  abs,
+  add,
   and,
   argmax,
   argmin,
   arrayAgg,
-  asColumn,
-  asRelation,
+  asLiteral,
+  asNode,
+  asTableRef,
+  asVerbatim,
+  asc,
   avg,
+  bin1d,
+  bin2d,
+  binLinear1d,
+  binLinear2d,
+  bitAnd,
+  bitLeft,
+  bitNot,
+  bitOr,
+  bitRight,
   cast,
-  castDouble,
-  castInteger,
+  ceil,
   centroid,
   centroidX,
   centroidY,
+  collectAggregates,
+  collectColumns,
+  collectParams,
   column,
+  cond,
   contains,
   corr,
   count,
   covarPop,
   covariance,
-  create,
+  createSchema,
+  createTable,
   cume_dist,
   dateBin,
   dateDay,
@@ -1345,56 +2497,77 @@ export {
   dateMonthDay,
   dense_rank,
   desc,
+  div,
   entropy,
   epoch_ms,
   eq,
+  exp,
   first,
   first_value,
+  float32,
+  float64,
+  floor,
   geojson,
+  greatest,
   gt,
   gte,
+  idiv,
+  int32,
+  interval,
+  isAggregateExpression,
   isBetween,
+  isColumnRef,
   isDescribeQuery,
   isDistinct,
   isFinite,
+  isIn,
   isInfinite,
   isNaN,
+  isNode,
   isNotBetween,
   isNotDistinct,
   isNotNull,
   isNull,
   isParamLike,
   isQuery,
-  isSQLExpression,
+  isSelectQuery,
+  isTableRef,
   kurtosis,
   lag,
   last,
   last_value,
   lead,
+  least,
   length,
+  lineDensity,
   literal,
-  literalToSQL,
+  ln,
   loadCSV,
   loadExtension,
   loadJSON,
   loadObjects,
   loadParquet,
   loadSpatial,
+  log,
   lower,
   lt,
   lte,
+  m4,
   mad,
   max,
-  mean,
   median,
   min,
+  mod,
   mode,
+  mul,
   neq,
   not,
   nth_value,
   ntile,
   or,
+  over,
   percent_rank,
+  pow,
   prefix,
   product,
   quantile,
@@ -1409,20 +2582,25 @@ export {
   regrSXY,
   regrSYY,
   regrSlope,
-  relation,
+  rewrite,
+  round,
   row_number,
   scaleTransform,
+  sign,
   skewness,
   sql,
+  sqrt,
   stddev,
   stddevPop,
   stringAgg,
+  sub,
   suffix,
   sum,
-  toSQL,
+  trunc,
   upper,
   varPop,
   variance,
+  walk,
   x,
   y
 };