@uwdata/mosaic-inputs 0.11.0 → 0.12.1

package/dist/mosaic-inputs.js

@@ -5,7 +5,8 @@ function throttle(callback, debounce = false) {
   let next;
   let pending = NIL;
   function invoke(event) {
-    curr = callback(event).finally(() => {
+    curr = callback(event).catch(() => {
+    }).finally(() => {
       if (next) {
         const { value } = next;
         next = null;
@@ -66,11 +67,12 @@ var MosaicClient = class {
     return this._filterBy;
   }
   /**
-   * Return a boolean indicating if the client query can be indexed. Should
-   * return true if changes to the filterBy selection does not change the
-   * groupby domain of the client query.
+   * Return a boolean indicating if the client query can be sped up with
+   * materialized views of pre-aggregated data. Should return true if changes to
+   * the filterBy selection does not change the groupby domain of the client
+   * query.
    */
-  get filterIndexable() {
+  get filterStable() {
     return true;
   }
   /**
@@ -737,8 +739,8 @@ function toNumber(value) {
   }
   return Number(value);
 }
-function divide(num, div) {
-  return Number(num / div) + Number(num % div) / Number(div);
+function divide(num, div2) {
+  return Number(num / div2) + Number(num % div2) / Number(div2);
 }
 var asUint64 = (v) => BigInt.asUintN(64, v);
 function fromDecimal128(buf2, offset) {
@@ -1056,14 +1058,14 @@ var Float16Batch = class extends NumberBatch {
     );
     const expo = (v & 31744) >> 10;
     const sigf = (v & 1023) / 1024;
-    const sign = (-1) ** ((v & 32768) >> 15);
+    const sign2 = (-1) ** ((v & 32768) >> 15);
     switch (expo) {
       case 31:
-        return sign * (sigf ? Number.NaN : 1 / 0);
+        return sign2 * (sigf ? Number.NaN : 1 / 0);
       case 0:
-        return sign * (sigf ? 6103515625e-14 * sigf : 0);
+        return sign2 * (sigf ? 6103515625e-14 * sigf : 0);
     }
-    return sign * 2 ** (expo - 15) * (1 + sigf);
+    return sign2 * 2 ** (expo - 15) * (1 + sigf);
   }
 };
 var BoolBatch = class extends ArrayBatch {
@@ -1729,8 +1731,8 @@ var Table = class _Table {
    * @returns {Table} A new table with columns matching the specified names.
    */
   select(names, as) {
-    const all2 = this.names;
-    const indices = names.map((name) => all2.indexOf(name));
+    const all = this.names;
+    const indices = names.map((name) => all.indexOf(name));
     return this.selectAt(indices, as);
   }
   /**
@@ -2485,7 +2487,9 @@ function socketConnector(uri = "ws://localhost:3000/") {
      * Query the DuckDB server.
      * @param {object} query
      * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
-     * @param {string} query.sql A SQL query string.
+     * @param {string} [query.sql] A SQL query string.
+     * @param {string[]} [query.queries] The queries used to create a bundle.
+     * @param {string} [query.name] The name of a bundle to create or load.
      * @returns the query result
      */
     query(query) {
@@ -2496,71 +2500,82 @@ function socketConnector(uri = "ws://localhost:3000/") {
   };
 }
 
-// ../sql/src/ref.js
-var Ref = class {
+// ../sql/src/constants.js
+var COLUMN_REF = "COLUMN_REF";
+var COLUMN_PARAM = "COLUMN_PARAM";
+var TABLE_REF = "TABLE_REF";
+var LITERAL = "LITERAL";
+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";
+
+// ../sql/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(table2, column2) {
-    if (table2) this.table = String(table2);
-    if (column2) this.column = column2;
+  constructor(type) {
+    this.type = type;
   }
+};
+var ExprNode = class extends SQLNode {
+};
+
+// ../sql/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: table2, column: column2 } = this;
-    if (column2) {
-      const col = column2.startsWith("*") ? column2 : `"${column2}"`;
-      return `${table2 ? `${quoteTableName(table2)}.` : ""}${col}`;
-    } else {
-      return table2 ? quoteTableName(table2) : "NULL";
-    }
+    return literalToSQL(this.value);
   }
 };
-function quoteTableName(table2) {
-  const pieces = table2.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(table2, column2 = null) {
-  if (arguments.length === 1) {
-    column2 = table2;
-    table2 = null;
-  }
-  return new Ref(table2, column2);
-}
-
-// ../sql/src/to-sql.js
 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";
@@ -2570,1032 +2585,1681 @@ 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}`;
       }
   }
 }
 
-// ../sql/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;
-    }
+// ../sql/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);
   }
+};
+
+// ../sql/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] === '"';
+}
+
+// ../sql/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(table2) {
+    super(TABLE_REF);
+    this.table = [table2].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(".");
   }
+};
+
+// ../sql/src/ast/function.js
+var FunctionNode = class extends ExprNode {
   /**
-   * 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.
+   * Instantiate a function node.
+   * @param {string} name The function name.
+   * @param {ExprNode[]} [args=[]] The function arguments.
    */
-  addEventListener(type, callback) {
-    const map2 = this.map || (this.map = /* @__PURE__ */ new Map());
-    const set = map2.get(type) || (map2.set(type, /* @__PURE__ */ new Set()), map2.get(type));
-    set.add(callback);
+  constructor(name, args = []) {
+    super(FUNCTION);
+    this.name = name;
+    this.args = args;
   }
-};
-function update(expr, callbacks) {
-  if (callbacks?.size) {
-    return Promise.allSettled(Array.from(callbacks, (fn) => fn(expr)));
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { name, args } = this;
+    return `${name}(${args.join(", ")})`;
   }
+};
+
+// ../sql/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 exprList(list2, cast2 = asNode) {
+  return list2.flat().filter((x2) => x2 != null).map((x2) => cast2(x2));
 }
-
-// ../sql/src/desc.js
-function desc(expr) {
-  const e = asColumn(expr);
-  return sql`${e} DESC NULLS LAST`.annotate({ label: e?.label, desc: true });
+function argsList(list2) {
+  const n = list2.length;
+  let i = n;
+  for (; i > 0 && list2[i - 1] === void 0; --i) ;
+  return i < n ? list2.slice(0, i) : list2;
 }
 
-// ../sql/src/literal.js
-var literal = (value) => ({
-  value,
-  toString: () => literalToSQL(value)
-});
-
-// ../sql/src/operators.js
-function visit2(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: visit2 });
-}
-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: visit2 });
-var not = unaryOp("NOT");
-var unaryPostOp = (op) => (a) => sql`(${asColumn(a)} ${op})`.annotate({ op, a, visit: visit2 });
-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: visit2 });
-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: visit2, field: a, range });
-}
-var isBetween = (a, range, exclusive) => rangeOp("BETWEEN", a, range, exclusive);
-
-// ../sql/src/repeat.js
-function repeat(length2, str) {
-  return Array.from({ length: length2 }, () => str);
+// ../sql/src/util/type-check.js
+function isString(value) {
+  return typeof value === "string";
 }
-
-// ../sql/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 });
-  };
+function isArray2(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 isNaN2 = functionCall("ISNAN");
-var isFinite = functionCall("ISFINITE");
-var isInfinite = functionCall("ISINF");
 
-// ../sql/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;
+// ../sql/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");
-
-// ../sql/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;
-  }
-  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}`;
+  range(extent) {
+    return new _WindowNode(this.func, this.def.range(extent));
   }
   /**
-   * Return a new derived aggregate function over distinct values.
-   * @returns {AggregateFunction} A new aggregate function.
+   * Generate a SQL query string for this node.
+   * @returns {string}
    */
-  distinct() {
-    const { aggregate: op, args, type, filter } = this;
-    return new _AggregateFunction(op, args, type, true, filter);
+  toString() {
+    return `${this.func} OVER ${this.def}`;
   }
+};
+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");
-
-// ../sql/src/datetime.js
-var epoch_ms = (expr) => {
-  return sql`epoch_ms(${asColumn(expr)})`;
-};
-
-// ../sql/src/spatial.js
-var geojson = functionCall("ST_AsGeoJSON");
-var x = functionCall("ST_X");
-var y = functionCall("ST_Y");
-var centroid = functionCall("ST_CENTROID");
-
-// ../sql/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 list2 = [];
-      const add = (as, q) => {
-        const query2 = q.clone();
-        query2.cteFor = this;
-        list2.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(list2);
-      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 list2 = [];
-      for (const e of expr.flat()) {
-        if (e == null) {
-        } else if (typeof e === "string") {
-          list2.push({ as: e, expr: asColumn(e) });
-        } else if (e instanceof Ref) {
-          list2.push({ as: e.column, expr: e });
-        } else if (Array.isArray(e)) {
-          list2.push({ as: e[0], expr: e[1] });
-        } else {
-          for (const as in e) {
-            list2.push({ as: unquote(as), expr: asColumn(e[as]) });
-          }
-        }
-      }
-      const keys = new Set(list2.map((x2) => x2.as));
-      query.select = query.select.filter((x2) => !keys.has(x2.as)).concat(list2.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 list2 = [];
-      expr.flat().forEach((e) => {
-        if (e == null) {
-        } else if (typeof e === "string") {
-          list2.push({ as: e, from: asRelation(e) });
-        } else if (e instanceof Ref) {
-          list2.push({ as: e.table, from: e });
-        } else if (isQuery(e) || isSQLExpression(e)) {
-          list2.push({ from: e });
-        } else if (Array.isArray(e)) {
-          list2.push({ as: unquote(e[0]), from: asRelation(e[1]) });
-        } else {
-          for (const as in e) {
-            list2.push({ as: unquote(as), from: asRelation(e[as]) });
-          }
-        }
-      });
-      query.from = query.from.concat(list2);
-      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}`;
+}
+
+// ../sql/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, table2) {
+    super(type);
+    this.table = table2;
   }
   /**
-   * 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: table2 } = this;
+    const tref = `${table2 ?? ""}`;
+    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, table2) {
+    super(COLUMN_REF, table2);
+    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 list2 = [];
-      expr.flat().forEach((e) => {
-        if (e == null) {
-        } else {
-          for (const as in e) {
-            list2.push({ as: unquote(as), expr: e[as] });
-          }
-        }
-      });
-      query.window = query.window.concat(list2);
-      return this;
-    }
+  get column() {
+    return this.name;
   }
+};
+
+// ../sql/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, table2) {
+    super(COLUMN_PARAM, table2);
+    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}`;
   }
+};
+
+// ../sql/src/functions/column.js
+function column(name, table2) {
+  const tref = asTableRef(table2);
+  return isParamLike(name) ? new ColumnParamNode(new ParamNode(name), tref) : new ColumnNameRefNode(name, tref);
+}
+
+// ../sql/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.
    */
+  constructor(value) {
+    super(VERBATIM);
+    this.value = value;
+  }
   /**
-  * 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;
-    }
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return this.value;
+  }
+};
+
+// ../sql/src/functions/literal.js
+function literal(value) {
+  return new LiteralNode(value);
+}
+function verbatim(value) {
+  return new VerbatimNode(value);
+}
+
+// ../sql/src/functions/table-ref.js
+function tableRef(...ids) {
+  const args = exprList(ids, String);
+  return args?.length ? new TableRefNode(args) : void 0;
+}
+
+// ../sql/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) : isArray2(value) ? tableRef(value) : value;
+}
+function parseColumnRef(ref) {
+  const ids = parseIdentifier(ref);
+  return column(ids.pop(), tableRef(ids));
+}
+function parseTableRef(ref) {
+  return tableRef(parseIdentifier(ref));
+}
+
+// ../sql/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, distinct2, filter) {
+    super(AGGREGATE);
+    this.name = name;
+    this.args = args;
+    this.isDistinct = distinct2;
+    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);
   }
   /**
-   * Retrieve current OFFSET value.
-   * @returns {number|null}
+   * 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"
+];
+
+// ../sql/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);
+  }
   /**
-  * Set the query result OFFSET.
-  * @param {number} value The offset value.
-  * @returns {this}
-  */
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return super.toSQL("NOT BETWEEN");
+  }
+};
+
+// ../sql/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})`;
+  }
+};
+
+// ../sql/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}`;
+  }
+};
+
+// ../sql/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("");
+  }
+};
+
+// ../sql/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})` : ""}`;
+  }
+};
+
+// ../sql/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;
+}
+
+// ../sql/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})`;
+  }
+};
+
+// ../sql/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) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.offset;
+    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 list2 = [];
+    const add2 = (name, q) => {
+      const query = q.clone();
+      query.cteFor = this;
+      list2.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(list2);
+    return this;
+  }
+  /**
+   * Add SELECT expressions.
+   * @param {...import('../types.js').SelectExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  select(...expr) {
+    const list2 = [];
+    const add2 = (v, as) => list2.push(
+      new SelectClauseNode(v == null ? v : asNode(v), unquote(as))
+    );
+    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 (isArray2(e)) add2(e[1], e[0]);
+      else for (const alias in e) add2(e[alias], alias);
+    });
+    const keys = new Set(list2.map((x2) => x2.alias));
+    this._select = this._select.filter((x2) => !keys.has(x2.alias)).concat(list2.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 list2 = [];
+    const add2 = (v, as) => list2.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 (isArray2(e)) add2(e[1], e[0]);
+      else for (const alias in e) add2(e[alias], alias);
+    });
+    this._from = this._from.concat(list2);
+    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 {
-      query.offset = Number.isFinite(value) ? value : void 0;
-      return this;
+      clause = value;
     }
+    this._sample = clause;
+    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);
+  /**
+   * 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 list2 = [];
+    expr.flat().forEach((e) => {
+      if (e != null) for (const name in e) {
+        list2.push(new WindowClauseNode(unquote(name), e[name]));
       }
     });
-    return q;
+    this._window = this._window.concat(list2);
+    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: cte,
-      select,
-      distinct: distinct2,
-      from,
-      sample,
-      where,
-      groupby,
-      having,
-      window,
-      qualify,
-      orderby,
-      limit,
-      offset
-    } = this.query;
+      _with,
+      _select,
+      _distinct,
+      _from,
+      _sample,
+      _where,
+      _groupby,
+      _having,
+      _window,
+      _qualify,
+      _orderby,
+      _limit,
+      _offset
+    } = this;
     const sql2 = [];
-    if (cte.length) {
-      const list2 = cte.map(({ as, query }) => `"${as}" AS (${query})`);
-      sql2.push(`WITH ${list2.join(", ")}`);
-    }
-    const sels = select.map(
-      ({ as, expr }) => isColumnRefFor(expr, as) && !expr.table ? `${expr}` : `${expr} AS "${as}"`
-    );
-    sql2.push(`SELECT${distinct2 ? " 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(", ")}`);
-    }
-    if (where.length) {
-      const clauses = where.map(String).filter((x2) => x2).join(" AND ");
+    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;
+  /**
+   * 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(" ");
+  }
+};
+
+// ../sql/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}`;
+  }
+};
+
+// ../sql/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(", ")}))`;
+  }
+};
+
+// ../sql/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);
+  }
+};
+
+// ../sql/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}`;
+  }
+};
+
+// ../sql/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 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})`;
+  }
+};
+
+// ../sql/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 count(expr) {
+  return aggFn("count", expr);
+}
+function max(expr) {
+  return aggFn("max", expr);
+}
+function min(expr) {
+  return aggFn("min", expr);
+}
+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 sum(expr) {
+  return aggFn("sum", expr);
+}
+
+// ../sql/src/functions/cast.js
+function cast(expr, type) {
+  return new CastNode(asNode(expr), type);
+}
+function int322(expr) {
+  return cast(expr, "INTEGER");
+}
+function float642(expr) {
+  return cast(expr, "DOUBLE");
+}
+
+// ../sql/src/functions/datetime.js
+function epoch_ms(expr) {
+  return fn("epoch_ms", expr);
+}
+
+// ../sql/src/functions/numeric.js
+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);
+}
+
+// ../sql/src/functions/operators.js
+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 isNull(expr) {
+  return unaryPostfixOp("IS NULL", expr);
+}
+function isNotNull(expr) {
+  return unaryPostfixOp("IS NOT NULL", expr);
+}
+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 pow(left, right) {
+  return binaryOp("**", left, right);
+}
+function isNotDistinct(left, right) {
+  return binaryOp("IS NOT DISTINCT FROM", left, right);
+}
+function isBetween(expr, extent) {
+  return betweenOp(expr, extent, false);
+}
+function isIn(expr, values) {
+  return new InOpNode(asNode(expr), values.map(asNode));
+}
+
+// ../sql/src/functions/order-by.js
+function desc(expr, nullsFirst) {
+  return new OrderByNode(asNode(expr), true, nullsFirst);
+}
+
+// ../sql/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.orderby = query.orderby.concat(
-        expr.flat().filter((x2) => x2).map(asColumn)
-      );
-      return this;
+      spans[k] += isString(e) ? e : literal(e);
     }
-  }
-  limit(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.limit;
+    const s = strings[++i];
+    if (isNode(spans[k])) {
+      spans[++k] = s;
     } else {
-      query.limit = Number.isFinite(value) ? value : void 0;
-      return this;
+      spans[k] += s;
     }
   }
-  offset(value) {
-    const { query } = this;
-    if (arguments.length === 0) {
-      return query.offset;
-    } else {
-      query.offset = Number.isFinite(value) ? value : void 0;
-      return this;
+  return spans.filter((s) => s).map((s) => isString(s) ? new VerbatimNode(s) : s);
+}
+
+// ../sql/src/functions/string.js
+function strFn(name, expr, ...args) {
+  return fn(name, expr, ...argsList(args).map(asLiteral));
+}
+function regexp_matches(string, pattern, options) {
+  return strFn("regexp_matches", string, pattern, options);
+}
+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);
+}
+
+// ../sql/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"]
+};
+
+// ../sql/src/visit/rewrite.js
+function rewrite(node, map2) {
+  if (map2.has(node)) {
+    return map2.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], map2);
+        }
+      } else if (child) {
+        node[prop] = rewrite(child, map2);
+      }
     }
   }
-  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}`);
+  return node;
+}
+
+// ../sql/src/visit/walk.js
+function walk(node, visit2) {
+  if (!isNode(node)) return;
+  const result = visit2(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], visit2) < 0) {
+          return result;
+        }
+      }
+    } else if (value && +walk(value, visit2) < 0) {
+      return -1;
     }
-    return sql2.join(" ");
   }
-};
-function isQuery(value) {
-  return value instanceof Query || value instanceof SetOperation;
 }
-function isDescribeQuery(value) {
-  return isQuery(value) && value.describe;
+
+// ../sql/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 unquote(s) {
-  return isDoubleQuoted(s) ? s.slice(1, -1) : s;
+function collectAggregates(root) {
+  const aggs = /* @__PURE__ */ new Set();
+  walk(root, (node) => {
+    if (node.type === AGGREGATE) {
+      aggs.add(node);
+    }
+  });
+  return Array.from(aggs);
 }
-function isDoubleQuoted(s) {
-  return s[0] === '"' && s[s.length - 1] === '"';
+function collectColumns(root) {
+  const cols = {};
+  walk(root, (node) => {
+    if (node.type === COLUMN_REF) {
+      cols[node] = node;
+    }
+  });
+  return Object.values(cols);
+}
+
+// ../sql/src/load/create.js
+function createTable2(name, query, {
+  replace = false,
+  temp = false,
+  view = false
+} = {}) {
+  return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// ../sql/src/scales.js
+// ../sql/src/transforms/scales.js
 var identity = (x2) => x2;
 function scaleLinear() {
   return {
     apply: identity,
     invert: identity,
-    sqlApply: asColumn,
+    sqlApply: asNode,
     sqlInvert: identity
   };
 }
@@ -3604,23 +4268,23 @@ function scaleLog({ base = null } = {}) {
     return {
       apply: Math.log,
       invert: Math.exp,
-      sqlApply: (c) => sql`LN(${asColumn(c)})`,
-      sqlInvert: (c) => sql`EXP(${c})`
+      sqlApply: (c) => ln(c),
+      sqlInvert: (c) => 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})`
+      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) => sql`LN(${asColumn(c)}) / LN(${b})`,
-      sqlInvert: (c) => sql`POW(${b}, ${c})`
+      sqlApply: (c) => div(ln(c), ln(b)),
+      sqlInvert: (c) => pow(b, c)
     };
   }
 }
@@ -3629,16 +4293,16 @@ function scaleSymlog({ constant = 1 } = {}) {
   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})) - ${_})`
+    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 = asColumn(c), sql`SIGN(${c}) * SQRT(ABS(${c}))`),
-    sqlInvert: (c) => sql`SIGN(${c}) * (${c}) ** 2`
+    sqlApply: (c) => (c = asNode(c), mul(sign(c), sqrt(abs(c)))),
+    sqlInvert: (c) => mul(sign(c), pow(c, 2))
   };
 }
 function scalePow({ exponent = 1 } = {}) {
@@ -3646,15 +4310,15 @@ function scalePow({ exponent = 1 } = {}) {
   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})`
+    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 ? +c : epoch_ms(asColumn(c)),
+    sqlApply: (c) => c instanceof Date ? literal(+c) : isDateLiteral(c) ? literal(+c.value) : epoch_ms(c),
     sqlInvert: identity
   };
 }
@@ -3672,259 +4336,8 @@ function scaleTransform(options) {
   const scale = scales[options.type];
   return scale ? { ...options, ...scale(options) } : null;
 }
-
-// ../sql/src/load/create.js
-function create(name, query, {
-  replace = false,
-  temp = true,
-  view = false
-} = {}) {
-  return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
-}
-
-// ../core/src/util/index-columns.js
-function indexColumns(client) {
-  if (!client.filterIndexable) return null;
-  const q = client.query();
-  const from = getBase(q, (q2) => q2.from()?.[0].from.table);
-  if (typeof from !== "string" || !q.select) return null;
-  const aggr = [];
-  const dims = [];
-  const aux = {};
-  const avg2 = (ref) => {
-    const name = ref.column;
-    const expr = getBase(q, (q2) => q2.select().find((c) => c.as === name)?.expr);
-    return `(SELECT AVG(${expr ?? ref}) FROM "${from}")`;
-  };
-  for (const entry of q.select()) {
-    const { as, expr: { aggregate, args } } = entry;
-    const op = aggregate?.toUpperCase?.();
-    switch (op) {
-      case "COUNT":
-      case "SUM":
-        aggr.push({ [as]: agg`SUM("${as}")::DOUBLE` });
-        break;
-      case "AVG":
-        aggr.push({ [as]: avgExpr(aux, as, args[0]) });
-        break;
-      case "ARG_MAX":
-        aggr.push({ [as]: argmaxExpr(aux, as, args) });
-        break;
-      case "ARG_MIN":
-        aggr.push({ [as]: argminExpr(aux, as, args) });
-        break;
-      // variance statistics drop the original aggregate operation
-      // in favor of tracking auxiliary sufficient statistics
-      case "VARIANCE":
-      case "VAR_SAMP":
-        aux[as] = null;
-        aggr.push({ [as]: varianceExpr(aux, args[0], avg2) });
-        break;
-      case "VAR_POP":
-        aux[as] = null;
-        aggr.push({ [as]: varianceExpr(aux, args[0], avg2, false) });
-        break;
-      case "STDDEV":
-      case "STDDEV_SAMP":
-        aux[as] = null;
-        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], avg2)})` });
-        break;
-      case "STDDEV_POP":
-        aux[as] = null;
-        aggr.push({ [as]: agg`SQRT(${varianceExpr(aux, args[0], avg2, false)})` });
-        break;
-      case "COVAR_SAMP":
-        aux[as] = null;
-        aggr.push({ [as]: covarianceExpr(aux, args, avg2) });
-        break;
-      case "COVAR_POP":
-        aux[as] = null;
-        aggr.push({ [as]: covarianceExpr(aux, args, avg2, false) });
-        break;
-      case "CORR":
-        aux[as] = null;
-        aggr.push({ [as]: corrExpr(aux, args, avg2) });
-        break;
-      // regression statistics
-      case "REGR_COUNT":
-        aux[as] = null;
-        aggr.push({ [as]: agg`${regrCountExpr(aux, args)}::DOUBLE` });
-        break;
-      case "REGR_AVGX":
-        aux[as] = null;
-        aggr.push({ [as]: regrAvgXExpr(aux, args) });
-        break;
-      case "REGR_AVGY":
-        aux[as] = null;
-        aggr.push({ [as]: regrAvgYExpr(aux, args) });
-        break;
-      case "REGR_SYY":
-        aux[as] = null;
-        aggr.push({ [as]: regrVarExpr(aux, 0, args, avg2) });
-        break;
-      case "REGR_SXX":
-        aux[as] = null;
-        aggr.push({ [as]: regrVarExpr(aux, 1, args, avg2) });
-        break;
-      case "REGR_SXY":
-        aux[as] = null;
-        aggr.push({ [as]: covarianceExpr(aux, args, avg2, null) });
-        break;
-      case "REGR_SLOPE":
-        aux[as] = null;
-        aggr.push({ [as]: regrSlopeExpr(aux, args, avg2) });
-        break;
-      case "REGR_INTERCEPT":
-        aux[as] = null;
-        aggr.push({ [as]: regrInterceptExpr(aux, args, avg2) });
-        break;
-      case "REGR_R2":
-        aux[as] = null;
-        aggr.push({ [as]: agg`(${corrExpr(aux, args, avg2)}) ** 2` });
-        break;
-      // aggregates that commute directly
-      case "MAX":
-      case "MIN":
-      case "BIT_AND":
-      case "BIT_OR":
-      case "BIT_XOR":
-      case "BOOL_AND":
-      case "BOOL_OR":
-      case "PRODUCT":
-        aggr.push({ [as]: agg`${op}("${as}")` });
-        break;
-      // otherwise, check if dimension
-      default:
-        if (!aggregate) dims.push(as);
-        else return null;
-    }
-  }
-  if (!aggr.length) return null;
-  return { from, dims, aggr, aux };
-}
-function auxName(type, ...args) {
-  const cols = args.length ? "_" + args.map(sanitize).join("_") : "";
-  return `__${type}${cols}__`;
-}
-function sanitize(col) {
-  return `${col}`.replaceAll('"', "").replaceAll(" ", "_");
-}
-function getBase(query, get) {
-  const subq = query.subqueries;
-  if (query.select && subq.length === 0) {
-    return get(query);
-  }
-  const base = getBase(subq[0], get);
-  for (let i = 1; i < subq.length; ++i) {
-    const value = getBase(subq[i], get);
-    if (value === void 0) continue;
-    if (value !== base) return NaN;
-  }
-  return base;
-}
-function countExpr(aux, arg) {
-  const n = auxName("count", arg);
-  aux[n] = agg`COUNT(${arg})`;
-  return agg`SUM(${n})`.annotate({ name: n });
-}
-function avgExpr(aux, as, arg) {
-  const n = countExpr(aux, arg);
-  return agg`(SUM("${as}" * ${n.name}) / ${n})`;
-}
-function argmaxExpr(aux, as, [, y2]) {
-  const max2 = auxName("max", y2);
-  aux[max2] = agg`MAX(${y2})`;
-  return agg`ARG_MAX("${as}", ${max2})`;
-}
-function argminExpr(aux, as, [, y2]) {
-  const min2 = auxName("min", y2);
-  aux[min2] = agg`MIN(${y2})`;
-  return agg`ARG_MIN("${as}", ${min2})`;
-}
-function varianceExpr(aux, x2, avg2, correction = true) {
-  const n = countExpr(aux, x2);
-  const ssq = auxName("rssq", x2);
-  const sum2 = auxName("rsum", x2);
-  const delta = sql`${x2} - ${avg2(x2)}`;
-  aux[ssq] = agg`SUM((${delta}) ** 2)`;
-  aux[sum2] = agg`SUM(${delta})`;
-  const adj = correction ? ` - 1` : "";
-  return agg`(SUM(${ssq}) - (SUM(${sum2}) ** 2 / ${n})) / (${n}${adj})`;
-}
-function covarianceExpr(aux, args, avg2, correction = true) {
-  const n = regrCountExpr(aux, args);
-  const sxy = regrSumXYExpr(aux, args, avg2);
-  const sx = regrSumExpr(aux, 1, args, avg2);
-  const sy = regrSumExpr(aux, 0, args, avg2);
-  const adj = correction === null ? "" : correction ? ` / (${n} - 1)` : ` / ${n}`;
-  return agg`(${sxy} - ${sx} * ${sy} / ${n})${adj}`;
-}
-function corrExpr(aux, args, avg2) {
-  const n = regrCountExpr(aux, args);
-  const sxy = regrSumXYExpr(aux, args, avg2);
-  const sxx = regrSumSqExpr(aux, 1, args, avg2);
-  const syy = regrSumSqExpr(aux, 0, args, avg2);
-  const sx = regrSumExpr(aux, 1, args, avg2);
-  const sy = regrSumExpr(aux, 0, args, avg2);
-  const vx = agg`(${sxx} - (${sx} ** 2) / ${n})`;
-  const vy = agg`(${syy} - (${sy} ** 2) / ${n})`;
-  return agg`(${sxy} - ${sx} * ${sy} / ${n}) / SQRT(${vx} * ${vy})`;
-}
-function regrCountExpr(aux, [y2, x2]) {
-  const n = auxName("count", y2, x2);
-  aux[n] = agg`REGR_COUNT(${y2}, ${x2})`;
-  return agg`SUM(${n})`.annotate({ name: n });
-}
-function regrSumExpr(aux, i, args, avg2) {
-  const v = args[i];
-  const o = args[1 - i];
-  const sum2 = auxName("rs", v);
-  aux[sum2] = agg`SUM(${v} - ${avg2(v)}) FILTER (${o} IS NOT NULL)`;
-  return agg`SUM(${sum2})`;
-}
-function regrSumSqExpr(aux, i, args, avg2) {
-  const v = args[i];
-  const u = args[1 - i];
-  const ssq = auxName("rss", v);
-  aux[ssq] = agg`SUM((${v} - ${avg2(v)}) ** 2) FILTER (${u} IS NOT NULL)`;
-  return agg`SUM(${ssq})`;
-}
-function regrSumXYExpr(aux, args, avg2) {
-  const [y2, x2] = args;
-  const sxy = auxName("sxy", y2, x2);
-  aux[sxy] = agg`SUM((${x2} - ${avg2(x2)}) * (${y2} - ${avg2(y2)}))`;
-  return agg`SUM(${sxy})`;
-}
-function regrAvgXExpr(aux, args) {
-  const [y2, x2] = args;
-  const n = regrCountExpr(aux, args);
-  const a = auxName("avg", x2, y2);
-  aux[a] = agg`REGR_AVGX(${y2}, ${x2})`;
-  return agg`(SUM(${a} * ${n.name}) / ${n})`;
-}
-function regrAvgYExpr(aux, args) {
-  const [y2, x2] = args;
-  const n = regrCountExpr(aux, args);
-  const a = auxName("avg", y2, x2);
-  aux[a] = agg`REGR_AVGY(${y2}, ${x2})`;
-  return agg`(SUM(${a} * ${n.name}) / ${n})`;
-}
-function regrVarExpr(aux, i, args, avg2) {
-  const n = regrCountExpr(aux, args);
-  const sum2 = regrSumExpr(aux, i, args, avg2);
-  const ssq = regrSumSqExpr(aux, i, args, avg2);
-  return agg`(${ssq} - (${sum2} ** 2 / ${n}))`;
-}
-function regrSlopeExpr(aux, args, avg2) {
-  const cov = covarianceExpr(aux, args, avg2, null);
-  const varx = regrVarExpr(aux, 1, args, avg2);
-  return agg`(${cov}) / ${varx}`;
-}
-function regrInterceptExpr(aux, args, avg2) {
-  const ax = regrAvgXExpr(aux, args);
-  const ay = regrAvgYExpr(aux, args);
-  const m = regrSlopeExpr(aux, args, avg2);
-  return agg`${ay} - (${m}) * ${ax}`;
+function isDateLiteral(x2) {
+  return x2 instanceof LiteralNode && x2.value instanceof Date;
 }
 
 // ../core/src/util/hash.js
@@ -3936,7 +4349,7 @@ function fnv_hash(v) {
     if (d) a = fnv_multiply(a ^ d >> 8);
     a = fnv_multiply(a ^ c & 255);
   }
-  return fnv_mix(a);
+  return fnv_mix(a) >>> 0;
 }
 function fnv_multiply(a) {
   return a + (a << 1) + (a << 4) + (a << 7) + (a << 8) + (a << 24);
@@ -3950,28 +4363,267 @@ function fnv_mix(a) {
   return a & 4294967295;
 }
 
-// ../core/src/DataCubeIndexer.js
+// ../core/src/preagg/sufficient-statistics.js
+function sufficientStatistics(node, preagg, avg2) {
+  switch (node.name) {
+    case "count":
+    case "sum":
+      return sumExpr(preagg, node);
+    case "avg":
+      return avgExpr(preagg, node);
+    case "arg_max":
+      return argmaxExpr(preagg, node);
+    case "arg_min":
+      return argminExpr(preagg, node);
+    // variance statistics drop the original aggregate operation
+    // in favor of tracking sufficient statistics
+    case "variance":
+    case "var_samp":
+      return varianceExpr(preagg, node, avg2);
+    case "var_pop":
+      return varianceExpr(preagg, node, avg2, false);
+    case "stddev":
+    case "stddev_samp":
+      return sqrt(varianceExpr(preagg, node, avg2));
+    case "stddev_pop":
+      return sqrt(varianceExpr(preagg, node, avg2, false));
+    case "covar_samp":
+      return covarianceExpr(preagg, node, avg2);
+    case "covar_pop":
+      return covarianceExpr(preagg, node, avg2, false);
+    case "corr":
+      return corrExpr(preagg, node, avg2);
+    // regression statistics
+    case "regr_count":
+      return regrCountExpr(preagg, node).expr;
+    case "regr_avgx":
+      return regrAvgXExpr(preagg, node);
+    case "regr_avgy":
+      return regrAvgYExpr(preagg, node);
+    case "regr_syy":
+      return regrVarExpr(preagg, 0, node, avg2);
+    case "regr_sxx":
+      return regrVarExpr(preagg, 1, node, avg2);
+    case "regr_sxy":
+      return covarianceExpr(preagg, node, avg2, null);
+    case "regr_slope":
+      return regrSlopeExpr(preagg, node, avg2);
+    case "regr_intercept":
+      return regrInterceptExpr(preagg, node, avg2);
+    case "regr_r2":
+      return pow(corrExpr(preagg, node, avg2), 2);
+    // aggregates that commute directly
+    case "max":
+    case "min":
+    case "bit_and":
+    case "bit_or":
+    case "bit_xor":
+    case "bool_and":
+    case "bool_or":
+    case "product": {
+      const name = colName(node);
+      preagg[name] = node;
+      return sql`${node.name}("${name}")`;
+    }
+    // unsupported aggregate, return null to indicate failure
+    default:
+      return null;
+  }
+}
+function colName(node) {
+  return "pre_" + fnv_hash(`${node}`).toString(16);
+}
+function addStat(preagg, expr, node) {
+  const filter = node?.filter;
+  if (filter) {
+    expr = expr.filter ? expr.where(and(filter, expr.filter)) : expr.where(filter);
+  }
+  const name = colName(expr);
+  preagg[name] = expr;
+  return name;
+}
+function countExpr(preagg, node) {
+  const name = addStat(preagg, count(node.args[0]), node);
+  return { expr: sum(name), name };
+}
+function sumExpr(preagg, node) {
+  return sum(addStat(preagg, node));
+}
+function avgExpr(preagg, node) {
+  const as = addStat(preagg, node);
+  const { expr, name } = countExpr(preagg, node);
+  return div(sum(mul(as, name)), expr);
+}
+function argmaxExpr(preagg, node) {
+  const expr = addStat(preagg, node);
+  const maxy = addStat(preagg, max(node.args[1]), node);
+  return argmax(expr, maxy);
+}
+function argminExpr(preagg, node) {
+  const expr = addStat(preagg, node);
+  const miny = addStat(preagg, min(node.args[1]), node);
+  return argmin(expr, miny);
+}
+function varianceExpr(preagg, node, avg2, correction = true) {
+  const x2 = node.args[0];
+  const { expr: n } = countExpr(preagg, node);
+  const delta = sub(x2, avg2(x2));
+  const rssq = addStat(preagg, sum(pow(delta, 2)), node);
+  const rsum = addStat(preagg, sum(delta), node);
+  const denom = correction ? sub(n, 1) : n;
+  return div(sub(sum(rssq), div(pow(sum(rsum), 2), n)), denom);
+}
+function covarianceExpr(preagg, node, avg2, correction = true) {
+  const { expr: n } = regrCountExpr(preagg, node);
+  const sxy = regrSumXYExpr(preagg, node, avg2);
+  const sx = regrSumExpr(preagg, 1, node, avg2);
+  const sy = regrSumExpr(preagg, 0, node, avg2);
+  const num = sub(sxy, div(mul(sx, sy), n));
+  return correction === null ? num : correction ? div(num, sub(n, 1)) : div(num, n);
+}
+function corrExpr(preagg, node, avg2) {
+  const { expr: n } = regrCountExpr(preagg, node);
+  const sxy = regrSumXYExpr(preagg, node, avg2);
+  const sxx = regrSumSqExpr(preagg, 1, node, avg2);
+  const syy = regrSumSqExpr(preagg, 0, node, avg2);
+  const sx = regrSumExpr(preagg, 1, node, avg2);
+  const sy = regrSumExpr(preagg, 0, node, avg2);
+  const vx = sub(sxx, div(pow(sx, 2), n));
+  const vy = sub(syy, div(pow(sy, 2), n));
+  return div(
+    sub(sxy, div(mul(sx, sy), n)),
+    sqrt(mul(vx, vy))
+  );
+}
+function regrCountExpr(preagg, node) {
+  const [x2, y2] = node.args;
+  const n = addStat(preagg, regrCount(x2, y2), node);
+  return { expr: sum(n), name: n };
+}
+function regrSumExpr(preagg, i, node, avg2) {
+  const args = node.args;
+  const v = args[i];
+  const o = args[1 - i];
+  const rsum = sum(sub(v, avg2(v))).where(isNotNull(o));
+  return sum(addStat(preagg, rsum, node));
+}
+function regrSumSqExpr(preagg, i, node, avg2) {
+  const args = node.args;
+  const v = args[i];
+  const u = args[1 - i];
+  const ssq = sum(pow(sub(v, avg2(v)), 2)).where(isNotNull(u));
+  return sum(addStat(preagg, ssq, node));
+}
+function regrSumXYExpr(preagg, node, avg2) {
+  const [y2, x2] = node.args;
+  const sxy = sum(mul(sub(x2, avg2(x2)), sub(y2, avg2(y2))));
+  return sum(addStat(preagg, sxy, node));
+}
+function regrAvgXExpr(preagg, node) {
+  const [y2, x2] = node.args;
+  const { expr: n, name } = regrCountExpr(preagg, node);
+  const a = addStat(preagg, regrAvgX(y2, x2), node);
+  return div(sum(mul(a, name)), n);
+}
+function regrAvgYExpr(preagg, node) {
+  const [y2, x2] = node.args;
+  const { expr: n, name } = regrCountExpr(preagg, node);
+  const a = addStat(preagg, regrAvgY(y2, x2), node);
+  return div(sum(mul(a, name)), n);
+}
+function regrVarExpr(preagg, i, node, avg2) {
+  const { expr: n } = regrCountExpr(preagg, node);
+  const sum2 = regrSumExpr(preagg, i, node, avg2);
+  const ssq = regrSumSqExpr(preagg, i, node, avg2);
+  return sub(ssq, div(pow(sum2, 2), n));
+}
+function regrSlopeExpr(preagg, node, avg2) {
+  const cov = covarianceExpr(preagg, node, avg2, null);
+  const varx = regrVarExpr(preagg, 1, node, avg2);
+  return div(cov, varx);
+}
+function regrInterceptExpr(preagg, node, avg2) {
+  const ax = regrAvgXExpr(preagg, node);
+  const ay = regrAvgYExpr(preagg, node);
+  const m = regrSlopeExpr(preagg, node, avg2);
+  return sub(ay, mul(m, ax));
+}
+
+// ../core/src/preagg/preagg-columns.js
+function preaggColumns(client) {
+  if (!client.filterStable) return null;
+  const q = client.query();
+  if (!isSelectQuery(q)) return null;
+  const from = getBase(q, (q2) => {
+    const ref = q2._from[0]?.expr;
+    return isTableRef(ref) ? ref.name : ref;
+  });
+  if (typeof from !== "string") return null;
+  const aggrs = /* @__PURE__ */ new Map();
+  const preagg = {};
+  const output = {};
+  const group = [];
+  const avg2 = (ref) => {
+    const name = ref.column;
+    const expr = getBase(q, (q2) => q2._select.find((c) => c.alias === name)?.expr);
+    return sql`(SELECT avg(${expr ?? ref}) FROM "${from}")`;
+  };
+  for (const { alias, expr } of q._select) {
+    if (isAggregateExpression(expr) > 1) return null;
+    const nodes = collectAggregates(expr);
+    if (nodes.length === 0) {
+      group.push(alias);
+      preagg[alias] = expr;
+    } else {
+      for (const node of nodes) {
+        if (node.isDistinct) return null;
+        const agg = sufficientStatistics(node, preagg, avg2);
+        if (!agg) return null;
+        aggrs.set(node, agg);
+      }
+      output[alias] = rewrite(expr, aggrs);
+    }
+  }
+  if (!aggrs.size) return null;
+  return { group, preagg, output };
+}
+function getBase(query, get) {
+  const subq = query.subqueries;
+  if (isSelectQuery(query) && subq.length === 0) {
+    return get(query);
+  }
+  const base = getBase(subq[0], get);
+  for (let i = 1; i < subq.length; ++i) {
+    const value = getBase(subq[i], get);
+    if (value === void 0) continue;
+    if (value !== base) return NaN;
+  }
+  return base;
+}
+
+// ../core/src/preagg/PreAggregator.js
 var Skip = { skip: true, result: null };
-var DataCubeIndexer = class {
+var PreAggregator = class {
   /**
-   * Create a new data cube index table manager.
-   * @param {import('./Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
-   * @param {DataCubeIndexerOptions} [options] Data cube indexer options.
+   * Create a new manager of materialized views of pre-aggregated data.
+   * @param {import('../Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
+   * @param {PreAggregateOptions} [options] Pre-aggregation options.
    */
   constructor(coordinator2, {
     schema = "mosaic",
     enabled = true
   } = {}) {
-    this.indexes = /* @__PURE__ */ new Map();
+    this.entries = /* @__PURE__ */ new Map();
     this.active = null;
     this.mc = coordinator2;
     this._schema = schema;
     this._enabled = enabled;
   }
   /**
-   * Set the enabled state of this indexer. If false, any local state is
-   * cleared and subsequent index calls will return null until re-enabled.
-   * This method has no effect on any index tables already in the database.
+   * Set the enabled state of this manager. If false, any local state is
+   * cleared and subsequent request calls will return null until re-enabled.
+   * This method has no effect on any pre-aggregated tables already in the
+   * database.
    * @param {boolean} [state] The enabled state to set.
    */
   set enabled(state) {
@@ -3981,17 +4633,17 @@ var DataCubeIndexer = class {
     }
   }
   /**
-   * Get the enabled state of this indexer.
+   * Get the enabled state of this manager.
    * @returns {boolean} The current enabled state.
    */
   get enabled() {
     return this._enabled;
   }
   /**
-   * Set the database schema used by this indexer. Upon changes, any local
-   * state is cleared. This method does _not_ drop any existing data cube
-   * tables, use `dropIndexTables` before changing the schema to also remove
-   * existing index tables in the database.
+   * Set the database schema used for pre-aggregated materialized view tables.
+   * Upon changes, any local state is cleared. This method does _not_ drop any
+   * existing materialized views, use `dropSchema` before changing the schema
+   * to also remove existing materalized views in the database.
    * @param {string} [schema] The schema name to set.
    */
   set schema(schema) {
@@ -4001,52 +4653,52 @@ var DataCubeIndexer = class {
     }
   }
   /**
-   * Get the database schema used by this indexer.
+   * Get the database schema used for pre-aggregated materialized view tables.
    * @returns {string} The current schema name.
    */
   get schema() {
     return this._schema;
   }
   /**
-   * Issues a query through the coordinator to drop the current index table
-   * schema. *All* tables in the schema will be removed and local state is
-   * cleared. Call this method if the underlying base tables have been updated,
-   * causing derived index tables to become stale and inaccurate. Use this
-   * method with care! Once dropped, the schema will be repopulated by future
-   * data cube indexer requests.
+   * Issues a query through the coordinator to drop the current schema for
+   * pre-aggregated materialized views. *All* materialized view tables in the
+   * schema will be removed and local state is cleared. Call this method if
+   * the underlying base tables have been updated, causing materialized view
+   * to become stale and inaccurate. Use this method with care! Once dropped,
+   * the schema will be repopulated by future pre-aggregation requests.
    * @returns A query result promise.
    */
-  dropIndexTables() {
+  dropSchema() {
     this.clear();
     return this.mc.exec(`DROP SCHEMA IF EXISTS "${this.schema}" CASCADE`);
   }
   /**
-   * Clear the cache of data cube index table entries for the current active
-   * selection clause. This method does _not_ drop any existing data cube
-   * tables. Use `dropIndexTables` to remove existing index tables from the
-   * database.
+   * Clear the cache of pre-aggregation entries for the current active
+   * selection clause. This method does _not_ drop any existing materialized
+   * views. Use `dropSchema` to remove existing materialized view tables from
+   * the database.
    */
   clear() {
-    this.indexes.clear();
+    this.entries.clear();
     this.active = null;
   }
   /**
-   * Return data cube index table information for the active state of a
-   * client-selection pair, or null if the client is not indexable. This
-   * method has multiple possible side effects, including data cube table
-   * generation and updating internal caches.
-   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
-   * @param {import('./Selection.js').Selection} selection A Mosaic selection
+   * Return pre-aggregation information for the active state of a
+   * client-selection pair, or null if the client has unstable filters.
+   * This method has multiple possible side effects, including materialized
+   * view creation and updating internal caches.
+   * @param {import('../MosaicClient.js').MosaicClient} client A Mosaic client.
+   * @param {import('../Selection.js').Selection} selection A Mosaic selection
    *  to filter the client by.
-   * @param {import('./util/selection-types.js').SelectionClause} activeClause
+   * @param {import('../util/selection-types.js').SelectionClause} activeClause
    *  A representative active selection clause for which to (possibly) generate
-   *  data cube index tables.
-   * @returns {DataCubeInfo | Skip | null} Data cube index table
-   *  information and query generator, or null if the client is not indexable.
+   *  materialized views of pre-aggregates.
+   * @returns {PreAggregateInfo | Skip | null} Information and query generator
+   * for pre-aggregated tables, or null if the client has unstable filters.
    */
-  index(client, selection, activeClause) {
+  request(client, selection, activeClause) {
     if (!this.enabled) return null;
-    const { indexes, mc, schema } = this;
+    const { entries, mc, schema } = this;
     const { source } = activeClause;
     if (!source) return null;
     if (this.active) {
@@ -4058,32 +4710,32 @@ var DataCubeIndexer = class {
       this.active = active = activeColumns(activeClause);
       if (active.source === null) return null;
     }
-    if (indexes.has(client)) {
-      return indexes.get(client);
+    if (entries.has(client)) {
+      return entries.get(client);
     }
-    const indexCols = indexColumns(client);
+    const preaggCols = preaggColumns(client);
     let info;
-    if (!indexCols) {
+    if (!preaggCols) {
       info = null;
     } else if (selection.skip(client, activeClause)) {
       info = Skip;
     } else {
       const filter = selection.remove(source).predicate(client);
-      info = dataCubeInfo(client.query(filter), active, indexCols, schema);
+      info = preaggregateInfo(client.query(filter), active, preaggCols, schema);
       info.result = mc.exec([
         `CREATE SCHEMA IF NOT EXISTS ${schema}`,
-        create(info.table, info.create, { temp: false })
+        createTable2(info.table, info.create, { temp: false })
       ]);
       info.result.catch((e) => mc.logger().error(e));
     }
-    indexes.set(client, info);
+    entries.set(client, info);
     return info;
   }
 };
 function activeColumns(clause) {
   const { source, meta } = clause;
   const clausePred = clause.predicate;
-  const clauseCols = clausePred?.columns;
+  const clauseCols = collectColumns(clausePred).map((c) => c.column);
   let predicate;
   let columns;
   if (!meta || !clauseCols) {
@@ -4093,92 +4745,206 @@ function activeColumns(clause) {
   if (type === "point") {
     predicate = (x2) => x2;
     columns = Object.fromEntries(
-      clauseCols.map((col) => [`${col}`, asColumn(col)])
+      clauseCols.map((col) => [`${col}`, asNode(col)])
     );
   } else if (type === "interval" && scales2) {
     const bins = scales2.map((s) => binInterval(s, pixelSize, bin));
     if (bins.some((b) => !b)) {
     } else if (bins.length === 1) {
-      predicate = (p) => p ? isBetween("active0", p.range.map(bins[0])) : [];
-      columns = { active0: bins[0](clausePred.field) };
+      predicate = (p) => p ? isBetween("active0", p.extent.map(bins[0])) : [];
+      columns = { active0: bins[0](clausePred.expr) };
     } else {
-      predicate = (p) => p ? and(p.children.map(
-        ({ range }, i) => isBetween(`active${i}`, range.map(bins[i]))
+      predicate = (p) => p ? and(p.clauses.map(
+        (c, i) => isBetween(`active${i}`, c.extent.map(bins[i]))
       )) : [];
       columns = Object.fromEntries(
         // @ts-ignore
-        clausePred.children.map((p, i) => [`active${i}`, bins[i](p.field)])
+        clausePred.clauses.map((p, i) => [`active${i}`, bins[i](p.expr)])
       );
     }
   }
   return { source: columns ? source : null, columns, predicate };
 }
-var BIN = { ceil: "CEIL", round: "ROUND" };
+var BIN = { ceil, round };
 function binInterval(scale, pixelSize, bin) {
   const { type, domain, range, apply, sqlApply } = scaleTransform(scale);
   if (!apply) return;
-  const fn = BIN[`${bin}`.toLowerCase()] || "FLOOR";
+  const binFn = BIN[`${bin}`.toLowerCase()] || floor;
   const lo = apply(Math.min(...domain));
   const hi = apply(Math.max(...domain));
-  const a = type === "identity" ? 1 : Math.abs(range[1] - range[0]) / (hi - lo);
-  const s = a / pixelSize === 1 ? "" : `${a / pixelSize}::DOUBLE * `;
-  const d = lo === 0 ? "" : ` - ${lo}::DOUBLE`;
-  return (value) => sql`${fn}(${s}(${sqlApply(value)}${d}))::INTEGER`;
+  const s = (type === "identity" ? 1 : Math.abs(range[1] - range[0]) / (hi - lo)) / pixelSize;
+  const scalar = s === 1 ? (x2) => x2 : (x2) => mul(float642(s), x2);
+  const diff = lo === 0 ? (x2) => x2 : (x2) => sub(x2, float642(lo));
+  return (value) => int322(binFn(scalar(diff(sqlApply(value)))));
+}
+function preaggregateInfo(clientQuery, active, preaggCols, schema) {
+  const { group, output, preagg } = preaggCols;
+  const { columns } = active;
+  const query = clientQuery.setSelect({ ...preagg, ...columns }).groupby(Object.keys(columns));
+  const [subq] = query.subqueries;
+  if (subq) {
+    const cols = Object.values(columns).flatMap((c) => collectColumns(c).map((c2) => c2.column));
+    subqueryPushdown(subq, cols);
+  }
+  const having = query._having;
+  const order = query._orderby;
+  query._having = [];
+  query._orderby = [];
+  const create2 = query.toString();
+  const id = (fnv_hash(create2) >>> 0).toString(16);
+  const table2 = `${schema}.preagg_${id}`;
+  const select = Query.select(group, output).from(table2).groupby(group).having(having).orderby(order);
+  return new PreAggregateInfo({ table: table2, create: create2, active, select });
+}
+function subqueryPushdown(query, cols) {
+  const memo = /* @__PURE__ */ new Set();
+  const pushdown = (q) => {
+    if (memo.has(q)) return;
+    memo.add(q);
+    if (isSelectQuery(q) && q._from.length) {
+      q.select(cols);
+    }
+    q.subqueries.forEach(pushdown);
+  };
+  pushdown(query);
+}
+var PreAggregateInfo = class {
+  /**
+   * Create a new pre-aggregation information instance.
+   * @param {object} options Options object.
+   * @param {string} options.table The materialized view table name.
+   * @param {string} options.create The table creation query.
+   * @param {*} options.active Active column information.
+   * @param {SelectQuery} options.select Base query for requesting updates
+   *  using a pre-aggregated materialized view.
+   */
+  constructor({ table: table2, create: create2, active, select }) {
+    this.table = table2;
+    this.create = create2;
+    this.result = null;
+    this.active = active;
+    this.select = select;
+    this.skip = false;
+  }
+  /**
+   * Generate a materialized view query for the given predicate.
+   * @param {import('@uwdata/mosaic-sql').ExprNode} predicate The current
+   *  active clause predicate.
+   * @returns {SelectQuery} A materialized view query.
+   */
+  query(predicate) {
+    return this.select.clone().where(this.active.predicate(predicate));
+  }
+};
+
+// ../core/src/util/js-type.js
+function jsType(type) {
+  switch (type) {
+    case "BIGINT":
+    case "HUGEINT":
+    case "INTEGER":
+    case "SMALLINT":
+    case "TINYINT":
+    case "UBIGINT":
+    case "UINTEGER":
+    case "USMALLINT":
+    case "UTINYINT":
+    // integers
+    case "DOUBLE":
+    case "FLOAT":
+    case "REAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+    case "TIME":
+    case "TIMESTAMP_NS":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+    case "JSON":
+      return "string";
+    case "ARRAY":
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+    case "GEOMETRY":
+      return "object";
+    default:
+      if (type.startsWith("DECIMAL")) {
+        return "number";
+      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
+        return "object";
+      } else if (type.endsWith("]")) {
+        return "array";
+      }
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+
+// ../core/src/util/field-info.js
+var Count = "count";
+var Nulls = "nulls";
+var Max = "max";
+var Min = "min";
+var Distinct = "distinct";
+var statMap = {
+  [Count]: count,
+  [Distinct]: (column2) => count(column2).distinct(),
+  [Max]: max,
+  [Min]: min,
+  [Nulls]: (column2) => count().where(isNull(column2))
+};
+function summarize(table2, column2, stats) {
+  return Query.from(table2).select(Array.from(stats, (s) => ({ [s]: statMap[s](column2) })));
 }
-function dataCubeInfo(clientQuery, active, indexCols, schema) {
-  const { dims, aggr, aux } = indexCols;
-  const { columns } = active;
-  const query = clientQuery.select({ ...columns, ...aux }).groupby(Object.keys(columns));
-  const [subq] = query.subqueries;
-  if (subq) {
-    const cols = Object.values(columns).flatMap((c) => c.columns);
-    subqueryPushdown(subq, cols);
+async function queryFieldInfo(mc, fields) {
+  if (fields.length === 1 && fields[0].column === "*") {
+    return getTableInfo(mc, fields[0].table);
+  } else {
+    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x2) => x2);
   }
-  const order = query.orderby();
-  query.query.orderby = [];
-  const create3 = query.toString();
-  const id = (fnv_hash(create3) >>> 0).toString(16);
-  const table2 = `${schema}.cube_${id}`;
-  const select = Query.select(dims, aggr).from(table2).groupby(dims).orderby(order);
-  return new DataCubeInfo({ id, table: table2, create: create3, active, select });
 }
-function subqueryPushdown(query, cols) {
-  const memo = /* @__PURE__ */ new Set();
-  const pushdown = (q) => {
-    if (memo.has(q)) return;
-    memo.add(q);
-    if (q.select && q.from().length) {
-      q.select(cols);
-    }
-    q.subqueries.forEach(pushdown);
+async function getFieldInfo(mc, { table: table2, column: column2, stats }) {
+  const q = Query.from({ source: table2 }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
+  const [desc2] = Array.from(await mc.query(Query.describe(q)));
+  const info = {
+    table: table2,
+    column: `${column2}`,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
   };
-  pushdown(query);
+  if (!(stats?.length || stats?.size)) return info;
+  const [result] = await mc.query(
+    summarize(table2, column2, stats),
+    { persist: true }
+  );
+  return Object.assign(info, result);
+}
+async function getTableInfo(mc, table2) {
+  const result = await mc.query(`DESCRIBE ${asTableRef(table2)}`);
+  return Array.from(result).map((desc2) => ({
+    table: table2,
+    column: desc2.column_name,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  }));
 }
-var DataCubeInfo = class {
-  /**
-   * Create a new DataCubeInfo instance.
-   * @param {object} options
-   */
-  constructor({ table: table2, create: create3, active, select } = {}) {
-    this.table = table2;
-    this.create = create3;
-    this.result = null;
-    this.active = active;
-    this.select = select;
-    this.skip = false;
-  }
-  /**
-   * Generate a data cube index table query for the given predicate.
-   * @param {import('@uwdata/mosaic-sql').SQLExpression} predicate The current
-   *  active clause predicate.
-   * @returns {Query} A data cube index table query.
-   */
-  query(predicate) {
-    return this.select.clone().where(this.active.predicate(predicate));
-  }
-};
 
 // ../core/src/util/query-result.js
+var QueryState = Object.freeze({
+  pending: Symbol("pending"),
+  ready: Symbol("ready"),
+  error: Symbol("error"),
+  done: Symbol("done")
+});
 var QueryResult = class extends Promise {
   /**
    * Create a new query result Promise.
@@ -4192,14 +4958,37 @@ var QueryResult = class extends Promise {
     });
     this._resolve = resolve;
     this._reject = reject;
+    this._state = QueryState.pending;
+    this._value = void 0;
   }
   /**
-   * Resolve the result Promise with the provided value.
+   * Resolve the result Promise with a prepared value or the provided value.
+   * This method will only succeed if either a value is provided or the promise is ready.
    * @param {*} value The result value.
    * @returns {this}
    */
   fulfill(value) {
-    this._resolve(value);
+    if (this._value !== void 0) {
+      if (value !== void 0) {
+        throw Error("Promise is ready and fulfill has a provided value");
+      }
+      this._resolve(this._value);
+    } else if (value === void 0) {
+      throw Error("Promise is neither ready nor has provided value");
+    } else {
+      this._resolve(value);
+    }
+    this._state = QueryState.done;
+    return this;
+  }
+  /**
+   * Prepare to resolve with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
+   */
+  ready(value) {
+    this._state = QueryState.ready;
+    this._value = value;
     return this;
   }
   /**
@@ -4208,18 +4997,42 @@ var QueryResult = class extends Promise {
    * @returns {this}
    */
   reject(error) {
+    this._state = QueryState.error;
     this._reject(error);
     return this;
   }
+  /**
+   * Returns the state of this query result.
+   * @returns {symbol}
+   */
+  get state() {
+    return this._state;
+  }
 };
 QueryResult.prototype.constructor = Promise;
 
+// ../core/src/util/void-logger.js
+function voidLogger() {
+  return {
+    debug(..._) {
+    },
+    info(..._) {
+    },
+    log(..._) {
+    },
+    warn(..._) {
+    },
+    error(..._) {
+    }
+  };
+}
+
 // ../core/src/QueryConsolidator.js
 function wait(callback) {
   const method = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : typeof setImmediate !== "undefined" ? setImmediate : setTimeout;
   return method(callback);
 }
-function consolidator(enqueue, cache, record) {
+function consolidator(enqueue, cache) {
   let pending = [];
   let id = 0;
   function run() {
@@ -4227,7 +5040,7 @@ function consolidator(enqueue, cache, record) {
     pending = [];
     id = 0;
     for (const group of groups) {
-      consolidate(group, enqueue, record);
+      consolidate(group, enqueue);
       processResults(group, cache);
     }
   }
@@ -4259,36 +5072,31 @@ function entryGroups(entries, cache) {
 }
 function consolidationKey(query, cache) {
   const sql2 = `${query}`;
-  if (query instanceof Query && !cache.get(sql2)) {
-    if (
-      // @ts-ignore
-      query.orderby().length || query.where().length || // @ts-ignore
-      query.qualify().length || query.having().length
-    ) {
+  if (isSelectQuery(query) && !cache.get(sql2)) {
+    if (query._orderby.length || query._where.length || query._qualify.length || query._having.length) {
       return sql2;
     }
-    const q = query.clone().$select("*");
-    const groupby = query.groupby();
+    const q = query.clone().setSelect("*");
+    const groupby = query._groupby;
     if (groupby.length) {
       const map2 = {};
-      query.select().forEach(({ as, expr }) => map2[as] = expr);
-      q.$groupby(groupby.map((e) => e instanceof Ref && map2[e.column] || e));
-    } else if (query.select().some(({ expr }) => expr.aggregate)) {
-      q.$groupby("ALL");
+      query._select.forEach(({ alias, expr }) => map2[alias] = expr);
+      q.setGroupby(groupby.map((e) => isColumnRef(e) && map2[e.column] || e));
+    } else if (query._select.some((e) => isAggregateExpression(e.expr))) {
+      q.setGroupby("ALL");
     }
     return `${q}`;
   } else {
     return sql2;
   }
 }
-function consolidate(group, enqueue, record) {
+function consolidate(group, enqueue) {
   if (shouldConsolidate(group)) {
     enqueue({
       request: {
         type: "arrow",
         cache: false,
-        record: false,
-        query: group.query = consolidatedQuery(group, record)
+        query: group.query = consolidatedQuery(group)
       },
       result: group.result = new QueryResult()
     });
@@ -4309,31 +5117,30 @@ function shouldConsolidate(group) {
   }
   return false;
 }
-function consolidatedQuery(group, record) {
+function consolidatedQuery(group) {
   const maps = group.maps = [];
   const fields = /* @__PURE__ */ new Map();
   for (const item of group) {
     const { query: query2 } = item.entry.request;
     const fieldMap = [];
     maps.push(fieldMap);
-    for (const { as, expr } of query2.select()) {
+    for (const { alias, expr } of query2._select) {
       const e = `${expr}`;
       if (!fields.has(e)) {
         fields.set(e, [`col${fields.size}`, expr]);
       }
       const [name] = fields.get(e);
-      fieldMap.push([name, as]);
+      fieldMap.push([name, alias]);
     }
-    record(`${query2}`);
   }
   const query = group[0].entry.request.query.clone();
-  const groupby = query.groupby();
+  const groupby = query._groupby;
   if (groupby.length) {
     const map2 = {};
     group.maps[0].forEach(([name, as]) => map2[as] = name);
-    query.$groupby(groupby.map((e) => e instanceof Ref && map2[e.column] || e));
+    query.setGroupby(groupby.map((e) => isColumnRef(e) && map2[e.column] || e));
   }
-  return query.$select(Array.from(fields.values()));
+  return query.setSelect(Array.from(fields.values()));
 }
 async function processResults(group, cache) {
   const { maps, query, result } = group;
@@ -4505,48 +5312,65 @@ var PriorityQueue = class {
 };
 
 // ../core/src/QueryManager.js
-var Priority = { High: 0, Normal: 1, Low: 2 };
+var Priority = Object.freeze({ High: 0, Normal: 1, Low: 2 });
 var QueryManager = class {
-  constructor() {
+  constructor(maxConcurrentRequests = 32) {
     this.queue = new PriorityQueue(3);
     this.db = null;
     this.clientCache = null;
-    this._logger = null;
+    this._logger = voidLogger();
     this._logQueries = false;
-    this.recorders = [];
-    this.pending = null;
     this._consolidate = null;
+    this.pendingResults = [];
+    this.maxConcurrentRequests = maxConcurrentRequests;
+    this.pendingExec = false;
   }
   next() {
-    if (this.pending || this.queue.isEmpty()) return;
+    if (this.queue.isEmpty() || this.pendingResults.length > this.maxConcurrentRequests || this.pendingExec) {
+      return;
+    }
     const { request, result } = this.queue.next();
-    this.pending = this.submit(request, result);
-    this.pending.finally(() => {
-      this.pending = null;
+    this.pendingResults.push(result);
+    if (request.type === "exec") this.pendingExec = true;
+    this.submit(request, result).finally(() => {
+      while (this.pendingResults.length && this.pendingResults[0].state !== QueryState.pending) {
+        const result2 = this.pendingResults.shift();
+        if (result2.state === QueryState.ready) {
+          result2.fulfill();
+        } else if (result2.state === QueryState.done) {
+          this._logger.warn("Found resolved query in pending results.");
+        }
+      }
+      if (request.type === "exec") this.pendingExec = false;
       this.next();
     });
   }
+  /**
+   * Add an entry to the query queue with a priority.
+   * @param {object} entry The entry to add.
+   * @param {*} [entry.request] The query request.
+   * @param {QueryResult} [entry.result] The query result.
+   * @param {number} priority The query priority, defaults to `Priority.Normal`.
+   */
   enqueue(entry, priority = Priority.Normal) {
     this.queue.insert(entry, priority);
     this.next();
   }
-  recordQuery(sql2) {
-    if (this.recorders.length && sql2) {
-      this.recorders.forEach((rec) => rec.add(sql2));
-    }
-  }
+  /**
+   * Submit the query to the connector.
+   * @param {*} request The request.
+   * @param {QueryResult} result The query result.
+   */
   async submit(request, result) {
     try {
-      const { query, type, cache = false, record = true, options } = request;
+      const { query, type, cache = false, options } = request;
       const sql2 = query ? `${query}` : null;
-      if (record) {
-        this.recordQuery(sql2);
-      }
       if (cache) {
         const cached = this.clientCache.get(sql2);
         if (cached) {
+          const data2 = await cached;
           this._logger.debug("Cache");
-          result.fulfill(cached);
+          result.ready(data2);
           return;
         }
       }
@@ -4554,10 +5378,12 @@ var QueryManager = class {
       if (this._logQueries) {
         this._logger.debug("Query", { type, sql: sql2, ...options });
       }
-      const data = await this.db.query({ type, sql: sql2, ...options });
+      const promise = this.db.query({ type, sql: sql2, ...options });
+      if (cache) this.clientCache.set(sql2, promise);
+      const data = await promise;
       if (cache) this.clientCache.set(sql2, data);
       this._logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
-      result.fulfill(data);
+      result.ready(type === "exec" ? null : data);
     } catch (err) {
       result.reject(err);
     }
@@ -4576,11 +5402,17 @@ var QueryManager = class {
   }
   consolidate(flag) {
     if (flag && !this._consolidate) {
-      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache, this.recordQuery.bind(this));
+      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache);
     } else if (!flag && this._consolidate) {
       this._consolidate = null;
     }
   }
+  /**
+   * Request a query result.
+   * @param {*} request The request.
+   * @param {number} priority The query priority, defaults to `Priority.Normal`.
+   * @returns {QueryResult} A query result promise.
+   */
   request(request, priority = Priority.Normal) {
     const result = new QueryResult();
     const entry = { request, result };
@@ -4601,6 +5433,11 @@ var QueryManager = class {
         }
         return false;
       });
+      for (const result of this.pendingResults) {
+        if (set.has(result)) {
+          result.reject("Canceled");
+        }
+      }
     }
   }
   clear() {
@@ -4608,145 +5445,12 @@ var QueryManager = class {
       result.reject("Cleared");
       return true;
     });
+    for (const result of this.pendingResults) {
+      result.reject("Cleared");
+    }
+    this.pendingResults = [];
   }
-  record() {
-    let state = [];
-    const recorder = {
-      add(query) {
-        state.push(query);
-      },
-      reset() {
-        state = [];
-      },
-      snapshot() {
-        return state.slice();
-      },
-      stop() {
-        this.recorders = this.recorders.filter((x2) => x2 !== recorder);
-        return state;
-      }
-    };
-    this.recorders.push(recorder);
-    return recorder;
-  }
-};
-
-// ../core/src/util/js-type.js
-function jsType(type) {
-  switch (type) {
-    case "BIGINT":
-    case "HUGEINT":
-    case "INTEGER":
-    case "SMALLINT":
-    case "TINYINT":
-    case "UBIGINT":
-    case "UINTEGER":
-    case "USMALLINT":
-    case "UTINYINT":
-    // integers
-    case "DOUBLE":
-    case "FLOAT":
-    case "REAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-    case "TIME":
-    case "TIMESTAMP_NS":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-    case "JSON":
-      return "string";
-    case "ARRAY":
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-    case "GEOMETRY":
-      return "object";
-    default:
-      if (type.startsWith("DECIMAL")) {
-        return "number";
-      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
-        return "object";
-      } else if (type.endsWith("]")) {
-        return "array";
-      }
-      throw new Error(`Unsupported type: ${type}`);
-  }
-}
-
-// ../core/src/util/field-info.js
-var Count = "count";
-var Nulls = "nulls";
-var Max = "max";
-var Min = "min";
-var Distinct = "distinct";
-var statMap = {
-  [Count]: count,
-  [Distinct]: (column2) => count(column2).distinct(),
-  [Max]: max,
-  [Min]: min,
-  [Nulls]: (column2) => count().where(isNull(column2))
 };
-function summarize(table2, column2, stats) {
-  return Query.from(table2).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
-}
-async function queryFieldInfo(mc, fields) {
-  if (fields.length === 1 && `${fields[0].column}` === "*") {
-    return getTableInfo(mc, fields[0].table);
-  } else {
-    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x2) => x2);
-  }
-}
-async function getFieldInfo(mc, { table: table2, column: column2, stats }) {
-  const q = Query.from({ source: table2 }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
-  const [desc2] = Array.from(await mc.query(Query.describe(q)));
-  const info = {
-    table: table2,
-    column: `${column2}`,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  };
-  if (!(stats?.length || stats?.size)) return info;
-  const [result] = await mc.query(
-    summarize(table2, column2, stats),
-    { persist: true }
-  );
-  return Object.assign(info, result);
-}
-async function getTableInfo(mc, table2) {
-  const result = await mc.query(`DESCRIBE ${asRelation(table2)}`);
-  return Array.from(result).map((desc2) => ({
-    table: table2,
-    column: desc2.column_name,
-    sqlType: desc2.column_type,
-    type: jsType(desc2.column_type),
-    nullable: desc2.null === "YES"
-  }));
-}
-
-// ../core/src/util/void-logger.js
-function voidLogger() {
-  return {
-    debug() {
-    },
-    info() {
-    },
-    log() {
-    },
-    warn() {
-    },
-    error() {
-    }
-  };
-}
 
 // ../core/src/Coordinator.js
 var _instance;
@@ -4764,7 +5468,7 @@ var Coordinator = class {
     manager = new QueryManager(),
     cache = true,
     consolidate: consolidate2 = true,
-    indexes = {}
+    preagg = {}
   } = {}) {
     this.manager = manager;
     this.manager.cache(cache);
@@ -4772,7 +5476,7 @@ var Coordinator = class {
     this.databaseConnector(db);
     this.logger(logger);
     this.clear();
-    this.dataCubeIndexer = new DataCubeIndexer(this, indexes);
+    this.preaggregator = new PreAggregator(this, preagg);
   }
   /**
    * Clear the coordinator state.
@@ -4910,12 +5614,12 @@ var Coordinator = class {
   /**
    * Issue a query request for a client. If the query is null or undefined,
    * the client is simply updated. Otherwise `updateClient` is called. As a
-   * side effect, this method clears the current data cube indexer state.
+   * side effect, this method clears the current preaggregator state.
    * @param {MosaicClient} client The client to update.
    * @param {QueryType | null} [query] The query to issue.
    */
   requestQuery(client, query) {
-    this.dataCubeIndexer.clear();
+    this.preaggregator.clear();
     return query ? this.updateClient(client, query) : Promise.resolve(client.update());
   }
   /**
@@ -4975,18 +5679,18 @@ function connectSelection(mc, selection, client) {
   entry.clients.add(client);
 }
 function activateSelection(mc, selection, clause) {
-  const { dataCubeIndexer, filterGroups } = mc;
+  const { preaggregator, filterGroups } = mc;
   const { clients } = filterGroups.get(selection);
   for (const client of clients) {
-    dataCubeIndexer.index(client, selection, clause);
+    preaggregator.request(client, selection, clause);
   }
 }
 function updateSelection(mc, selection) {
-  const { dataCubeIndexer, filterGroups } = mc;
+  const { preaggregator, filterGroups } = mc;
   const { clients } = filterGroups.get(selection);
   const { active } = selection;
   return Promise.allSettled(Array.from(clients, (client) => {
-    const info = dataCubeIndexer.index(client, selection, active);
+    const info = preaggregator.request(client, selection, active);
     const filter = info ? null : selection.predicate(client);
     if (info?.skip || !info && !filter) return;
     const query = info?.query(active.predicate) ?? client.query(filter);
@@ -5204,11 +5908,11 @@ var Param = class _Param extends AsyncDispatch {
   static array(values) {
     if (values.some((v) => isParam(v))) {
       const p = new _Param();
-      const update2 = () => {
+      const update = () => {
         p.update(values.map((v) => isParam(v) ? v.value : v));
       };
-      update2();
-      values.forEach((v) => isParam(v) ? v.addEventListener("value", update2) : 0);
+      update();
+      values.forEach((v) => isParam(v) ? v.addEventListener("value", update) : 0);
       return p;
     }
     return new _Param(values);
@@ -5255,7 +5959,7 @@ var Param = class _Param extends AsyncDispatch {
 function isSelection(x2) {
   return x2 instanceof Selection;
 }
-function create2(options, include) {
+function create(options, include) {
   return new Selection(
     new SelectionResolver(options),
     include ? [include].flat() : include
@@ -5278,7 +5982,7 @@ var Selection = class _Selection extends Param {
    * @returns {Selection} The new Selection instance.
    */
   static intersect({ cross = false, empty = false, include = [] } = {}) {
-    return create2({ cross, empty }, include);
+    return create({ cross, empty }, include);
   }
   /**
    * Create a new Selection instance with a
@@ -5296,7 +6000,7 @@ var Selection = class _Selection extends Param {
    * @returns {Selection} The new Selection instance.
    */
   static union({ cross = false, empty = false, include = [] } = {}) {
-    return create2({ cross, empty, union: true }, include);
+    return create({ cross, empty, union: true }, include);
   }
   /**
    * Create a new Selection instance with a singular resolution strategy
@@ -5314,7 +6018,7 @@ var Selection = class _Selection extends Param {
    * @returns {Selection} The new Selection instance.
    */
   static single({ cross = false, empty = false, include = [] } = {}) {
-    return create2({ cross, empty, single: true }, include);
+    return create({ cross, empty, single: true }, include);
   }
   /**
    * Create a new Selection instance with a
@@ -5329,7 +6033,7 @@ var Selection = class _Selection extends Param {
    * @returns {Selection} The new Selection instance.
    */
   static crossfilter({ empty = false, include = [] } = {}) {
-    return create2({ cross: true, empty }, include);
+    return create({ cross: true, empty }, include);
   }
   /**
    * Create a new Selection instance.
@@ -5524,16 +6228,18 @@ var SelectionResolver = class {
   }
   /**
    * Return a selection query predicate for the given client.
-   * @param {*[]} clauseList An array of selection clauses.
-   * @param {*} active The current active selection clause.
-   * @param {*} client The client whose data may be filtered.
+   * @param {import('./util/selection-types.js').SelectionClause[]} clauseList
+   *  An array of selection clauses.
+   * @param {import('./util/selection-types.js').SelectionClause} active
+   *  The current active selection clause.
+   * @param {MosaicClient} client The client whose data may be filtered.
    * @returns {*} The query predicate for filtering client data,
    *  based on the current state of this selection.
    */
   predicate(clauseList, active, client) {
     const { empty, union: union2 } = this;
     if (empty && !clauseList.length) {
-      return ["FALSE"];
+      return [literal(false)];
     }
     if (this.skip(client, active)) return void 0;
     const predicates = clauseList.filter((clause) => !this.skip(client, clause)).map((clause) => clause.predicate);
@@ -5559,7 +6265,7 @@ function clausePoint(field2, value, {
   source,
   clients = source ? /* @__PURE__ */ new Set([source]) : void 0
 }) {
-  const predicate = value !== void 0 ? isNotDistinct(field2, literal(value)) : null;
+  const predicate = value !== void 0 ? isIn(field2, [literal(value)]) : null;
   return {
     meta: { type: "point" },
     source,
@@ -5574,11 +6280,8 @@ function clausePoints(fields, value, {
 }) {
   let predicate = null;
   if (value) {
-    const clauses = value.map((vals) => {
-      const list2 = vals.map((v, i) => isNotDistinct(fields[i], literal(v)));
-      return list2.length > 1 ? and(list2) : list2[0];
-    });
-    predicate = clauses.length > 1 ? or(clauses) : clauses[0];
+    const clauses = value.length && fields.length === 1 ? [isIn(fields[0], value.map((v) => literal(v[0])))] : value.map((v) => and(v.map((_, i) => isNotDistinct(fields[i], literal(_)))));
+    predicate = value.length === 0 ? literal(false) : clauses.length > 1 ? or(clauses) : clauses[0];
   }
   return {
     meta: { type: "point" },
@@ -5605,8 +6308,8 @@ function clauseMatch(field2, value, {
   clients = void 0,
   method = "contains"
 }) {
-  let fn = MATCH_METHODS[method];
-  const predicate = value ? fn(field2, literal(value)) : null;
+  let fn2 = MATCH_METHODS[method];
+  const predicate = value ? fn2(field2, literal(value)) : null;
   const meta = { type: "match", method };
   return { meta, source, clients, value, predicate };
 }
@@ -5726,6 +6429,11 @@ var Menu = class extends MosaicClient {
             this.selectedValue(value2);
           }
         });
+      } else {
+        this.select.addEventListener("pointerenter", (evt) => {
+          if (!evt.buttons) this.activate();
+        });
+        this.select.addEventListener("focus", () => this.activate());
       }
     }
   }
@@ -5745,6 +6453,9 @@ var Menu = class extends MosaicClient {
   reset() {
     this.select.selectedIndex = this.from ? 0 : -1;
   }
+  activate() {
+    this.selection.activate(clausePoint(this.field, 0, { source: this }));
+  }
   publish(value) {
     const { selection, field: field2 } = this;
     if (isSelection(selection)) {
@@ -5851,17 +6562,28 @@ var Search = class extends MosaicClient {
             this.searchbox.value = value;
           }
         });
+      } else {
+        this.searchbox.addEventListener("pointerenter", (evt) => {
+          if (!evt.buttons) this.activate();
+        });
+        this.searchbox.addEventListener("focus", () => this.activate());
       }
     }
   }
   reset() {
     this.searchbox.value = "";
   }
+  clause(value) {
+    const { field: field2, type } = this;
+    return clauseMatch(field2, value, { source: this, method: type });
+  }
+  activate() {
+    this.selection.activate(this.clause(""));
+  }
   publish(value) {
-    const { selection, field: field2, type } = this;
+    const { selection } = this;
     if (isSelection(selection)) {
-      const clause = clauseMatch(field2, value, { source: this, method: type });
-      selection.update(clause);
+      selection.update(this.clause(value));
     } else if (isParam(selection)) {
       selection.update(value);
     }
@@ -5981,13 +6703,20 @@ var Slider = class extends MosaicClient {
       this.curval.innerText = value2;
       if (this.selection) this.publish(+value2);
     });
-    if (this.selection && !isSelection(this.selection)) {
-      this.selection.addEventListener("value", (value2) => {
-        if (value2 !== +this.slider.value) {
-          this.slider.value = value2;
-          this.curval.innerText = value2;
-        }
-      });
+    if (this.selection) {
+      if (!isSelection(this.selection)) {
+        this.selection.addEventListener("value", (value2) => {
+          if (value2 !== +this.slider.value) {
+            this.slider.value = value2;
+            this.curval.innerText = value2;
+          }
+        });
+      } else {
+        this.slider.addEventListener("pointerenter", (evt) => {
+          if (!evt.buttons) this.activate();
+        });
+        this.slider.addEventListener("focus", () => this.activate());
+      }
     }
   }
   query(filter = []) {
@@ -6011,20 +6740,27 @@ var Slider = class extends MosaicClient {
     }
     return this;
   }
+  clause(value) {
+    const { field: field2, selectionType } = this;
+    if (selectionType === "interval") {
+      const domain = [this.min ?? 0, value];
+      return clauseInterval(field2, domain, {
+        source: this,
+        bin: "ceil",
+        scale: { type: "identity", domain },
+        pixelSize: this.step
+      });
+    } else {
+      return clausePoint(field2, value, { source: this });
+    }
+  }
+  activate() {
+    this.selection.activate(this.clause(0));
+  }
   publish(value) {
-    const { field: field2, selectionType, selection } = this;
+    const { selection } = this;
     if (isSelection(selection)) {
-      if (selectionType === "interval") {
-        const domain = [this.min ?? 0, value];
-        selection.update(clauseInterval(field2, domain, {
-          source: this,
-          bin: "ceil",
-          scale: { type: "identity", domain },
-          pixelSize: this.step
-        }));
-      } else {
-        selection.update(clausePoint(field2, value, { source: this }));
-      }
+      selection.update(this.clause(value));
     } else if (isParam(this.selection)) {
       selection.update(value);
     }
@@ -6095,6 +6831,9 @@ var Table2 = class extends MosaicClient {
     this.format = format2;
     this.align = align2;
     this.widths = typeof width === "object" ? width : {};
+    if (isParam(from)) {
+      from.addEventListener("value", () => this.initialize());
+    }
     this.offset = 0;
     this.limit = +rowBatch;
     this.pending = false;
@@ -6144,6 +6883,9 @@ var Table2 = class extends MosaicClient {
     this.style = document.createElement("style");
     this.element.appendChild(this.style);
   }
+  sourceTable() {
+    return isParam(this.from) ? this.from.value : this.from;
+  }
   clause(rows = []) {
     const { data, limit, schema } = this;
     const fields = schema.map((s) => s.column);
@@ -6160,7 +6902,8 @@ var Table2 = class extends MosaicClient {
     coordinator().prefetch(query.clone().offset(offset + this.limit));
   }
   fields() {
-    return this.columns.map((name) => column(this.from, name));
+    const from = this.sourceTable();
+    return this.columns.map((name) => column(name, from));
   }
   fieldInfo(info) {
     this.schema = info;
@@ -6184,8 +6927,8 @@ var Table2 = class extends MosaicClient {
     return this;
   }
   query(filter = []) {
-    const { from, limit, offset, schema, sortColumn, sortDesc } = this;
-    return Query.from(from).select(schema.map((s) => s.column)).where(filter).orderby(sortColumn ? sortDesc ? desc(sortColumn) : sortColumn : []).limit(limit).offset(offset);
+    const { limit, offset, schema, sortColumn, sortDesc } = this;
+    return Query.from(this.sourceTable()).select(schema.map((s) => s.column)).where(filter).orderby(sortColumn ? sortDesc ? desc(sortColumn) : sortColumn : []).limit(limit).offset(offset);
   }
   queryResult(data) {
     if (!this.pending) {