@uwdata/mosaic-sql 0.19.0 → 0.20.1

package/src/ast/window-frame.ts

@@ -1,7 +1,7 @@
 import { WINDOW_EXTENT_EXPR, WINDOW_FRAME } from '../constants.js';
 import { type ParamLike } from '../types.js';
 import { isParamLike } from '../util/type-check.js';
-import { type ExprNode, isNode, SQLNode } from './node.js';
+import { type ExprNode, SQLNode } from './node.js';
 import { ParamNode } from './param.js';
 
 export type FrameValue =  ExprNode | number | null;
@@ -42,27 +42,6 @@ export class WindowFrameNode extends SQLNode {
     this.extent = isParamLike(extent) ? new ParamNode(extent) : extent;
     this.exclude = exclude;
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    const { frameType, exclude, extent } = this;
-    const [prev, next] = isNode(extent)
-      ? extent.value as [unknown, unknown]
-      : extent;
-    const a = asFrameExpr(prev, PRECEDING);
-    const b = asFrameExpr(next, FOLLOWING);
-    return `${frameType} BETWEEN ${a} AND ${b}${exclude ? ` ${exclude}` : ''}`;
-  }
-}
-
-function asFrameExpr(value: unknown, scope: string) {
-  return value instanceof WindowFrameExprNode ? value
-    : value != null && typeof value !== 'number' ? `${value} ${scope}`
-    : value === 0 ? CURRENT_ROW
-    : !(value && Number.isFinite(value)) ? `${UNBOUNDED} ${scope}`
-    : `${Math.abs(value)} ${scope}`;
 }
 
 export class WindowFrameExprNode extends SQLNode {
@@ -84,14 +63,4 @@ export class WindowFrameExprNode extends SQLNode {
     this.scope = scope;
     this.expr = expr;
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    const { scope, expr } = this;
-    return scope === CURRENT_ROW
-      ? scope
-      : `${expr ?? UNBOUNDED} ${scope}`;
-  }
 }

package/src/ast/window.ts

@@ -3,7 +3,6 @@ import type { AggregateNode } from './aggregate.js';
 import type { WindowFrameNode } from './window-frame.js';
 import { WINDOW, WINDOW_CLAUSE, WINDOW_DEF, WINDOW_FUNCTION } from '../constants.js';
 import { nodeList } from '../util/function.js';
-import { quoteIdentifier } from '../util/string.js';
 import { ExprNode, SQLNode } from './node.js';
 
 export class WindowClauseNode extends SQLNode {
@@ -22,13 +21,6 @@ export class WindowClauseNode extends SQLNode {
     this.name = name;
     this.def = def;
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    return `${quoteIdentifier(this.name)} AS ${this.def}`;
-  }
 }
 
 export class WindowNode extends ExprNode {
@@ -84,13 +76,6 @@ export class WindowNode extends ExprNode {
   frame(framedef: WindowFrameNode) {
     return new WindowNode(this.func, this.def.frame(framedef));
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    return `${this.func} OVER ${this.def}`;
-  }
 }
 
 export class WindowFunctionNode extends ExprNode {
@@ -123,19 +108,6 @@ export class WindowFunctionNode extends ExprNode {
     this.ignoreNulls = ignoreNulls;
     this.order = nodeList([argOrder]);
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    const { name, args, ignoreNulls, order } = this;
-    const arg = [
-      args.join(', '),
-      order.length ? `ORDER BY ${order.join(', ')}` : '',
-      ignoreNulls ? 'IGNORE NULLS' : ''
-    ].filter(x => x).join(' ');
-    return `${name}(${arg})`;
-  }
 }
 
 export class WindowDefNode extends SQLNode {
@@ -203,21 +175,6 @@ export class WindowDefNode extends SQLNode {
   frame(framedef: WindowFrameNode) {
     return deriveDef(this, { framedef });
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    const { name, partition, order, framedef } = this;
-    const base = name && quoteIdentifier(name);
-    const def = [
-      base,
-      partition?.length && `PARTITION BY ${partition.join(', ')}`,
-      order?.length && `ORDER BY ${order.join(', ')}`,
-      framedef
-    ].filter(x => x);
-    return base && def.length < 2 ? base : `(${def.join(' ')})`;
-  }
 }
 
 interface DeriveDefOptions {

package/src/ast/with.ts

@@ -29,15 +29,4 @@ export class WithClauseNode extends SQLNode {
     this.query = query;
     this.materialized = materialized;
   }
-
-  /**
-   * Generate a SQL query string for this node.
-   */
-  toString() {
-    const flag = this.materialized;
-    const mat = flag === true ? ' MATERIALIZED'
-      : flag === false ? ' NOT MATERIALIZED'
-      : '';
-    return `"${this.name}" AS${mat} (${this.query})`;
-  }
 }

package/src/constants.ts

@@ -27,6 +27,7 @@ export const WINDOW_FUNCTION = 'WINDOW_FUNCTION';
 export const WINDOW_DEF = 'WINDOW_DEF';
 export const WINDOW_FRAME = 'WINDOW_FRAME';
 export const WINDOW_EXTENT_EXPR = 'WINDOW_EXTENT_EXPR';
+export const CUSTOM = 'CUSTOM';
 
 export const EXPRESSION = 'EXPRESSION';
 export const FRAGMENT = 'FRAGMENT';
@@ -37,6 +38,7 @@ export const WITH_CLAUSE = 'WITH_CLAUSE';
 export const WINDOW_CLAUSE = 'WINDOW_CLAUSE';
 export const SELECT_CLAUSE = 'SELECT_CLAUSE';
 export const FROM_CLAUSE = 'FROM_CLAUSE';
+export const JOIN_CLAUSE = 'JOIN_CLAUSE';
 export const SAMPLE_CLAUSE = 'SAMPLE_CLAUSE';
 
 export const SELECT_QUERY = 'SELECT_QUERY';

package/src/functions/from.ts

@@ -0,0 +1,18 @@
+import { FromClauseNode } from "../ast/from.js";
+import { SampleClauseNode } from "../ast/sample.js";
+import { TableRefNode } from "../ast/table-ref.js";
+import { asTableRef } from "../util/ast.js";
+
+/**
+ * Create a new table FROM reference, applicable in a query or join.
+ * @param table The table.
+ * @param alias An optional table alias.
+ * @param sample An optional table sample to apply.
+ */
+export function from(
+  table: string | string[] | TableRefNode,
+  alias?: string,
+  sample?: SampleClauseNode
+) {
+  return new FromClauseNode(asTableRef(table)!, alias, sample);
+}

package/src/functions/join.ts

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

package/src/index.ts

@@ -1,3 +1,6 @@
+// Initialize default visitor
+import './init.js';
+
 export { AggregateNode, aggregateNames, isAggregateFunction } from './ast/aggregate.js';
 export { BetweenOpNode, NotBetweenOpNode } from './ast/between-op.js'
 export { BinaryOpNode } from './ast/binary-op.js';
@@ -11,9 +14,10 @@ export { FromClauseNode } from './ast/from.js';
 export { FunctionNode } from './ast/function.js';
 export { InOpNode } from './ast/in-op.js';
 export { IntervalNode } from './ast/interval.js';
+export { JoinNode, type JoinType, type JoinVariant } from './ast/join.js';
 export { ListNode } from './ast/list.js';
 export { LiteralNode } from './ast/literal.js';
-export { AndNode, OrNode } from './ast/logical-op.js';
+export { LogicalOpNode, AndNode, OrNode } from './ast/logical-op.js';
 export { SQLNode, ExprNode, isNode } from './ast/node.js';
 export { OrderByNode } from './ast/order-by.js';
 export { ParamNode } from './ast/param.js';
@@ -36,7 +40,9 @@ export { collate } from './functions/collate.js';
 export { column } from './functions/column.js';
 export { cte } from './functions/cte.js';
 export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms } from './functions/datetime.js';
+export { from } from './functions/from.js';
 export { days, hours, interval, microseconds, minutes, milliseconds, months, seconds, years } from './functions/interval.js';
+export { asof_join, cross_join, join, positional_join } from './functions/join.js';
 export { list, listContains, listHasAll, listHasAny } from './functions/list.js';
 export { literal, verbatim } from './functions/literal.js';
 export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from './functions/numeric.js';
@@ -54,6 +60,8 @@ export { deepClone } from './visit/clone.js';
 export { rewrite } from './visit/rewrite.js';
 export { collectAggregates, collectColumns, collectParams, isAggregateExpression } from './visit/visitors.js';
 export { walk, type VisitorCallback, type VisitorResult } from './visit/walk.js';
+export { SQLCodeGenerator } from './visit/codegen/sql.js';
+export { DuckDBCodeGenerator, duckDBCodeGenerator } from './visit/codegen/duckdb.js';
 
 export { createTable, createSchema } from './load/create.js';
 export { loadExtension } from './load/extension.js';

package/src/init.ts

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

package/src/transforms/bin-histogram.ts

@@ -3,6 +3,7 @@ import type { ExprValue } from '../types.js';
 import { float64 } from '../functions/cast.js';
 import { floor } from '../functions/numeric.js';
 import { add, div, mul, sub } from '../functions/operators.js';
+import { asNode } from '../util/ast.js';
 import { binSpec } from './util/bin-step.js';
 import { Scale, scaleTransform } from './scales.js';
 
@@ -47,14 +48,19 @@ export function binHistogram(
 ): ExprNode {
   const [min, max] = extent;
   const { offset = 0 } = options;
+
+  // handle degenerate extent
+  if (max === min) return offset ? add(offset, field) : asNode(field);
+
   const { apply, sqlApply, sqlInvert } = transform;
   const b = binSpec(apply(min), apply(max), options);
   const col = sqlApply(field);
-  const alpha = (b.max - b.min) / b.steps;
+  const alpha = ((b.max - b.min) / b.steps) || 1;
 
   let expr = b.min === 0 ? col : sub(col, b.min);
   if (alpha !== 1) expr = div(expr, float64(alpha));
-  expr = floor(offset ? add(offset, expr) : expr);
+  // add offset *after* floor to dodge nasty floating point nuances
+  expr = offset ? add(offset, floor(expr)) : floor(expr);
   if (alpha !== 1) expr = mul(alpha, expr);
   if (b.min !== 0) expr = add(b.min, expr);
   return sqlInvert(expr);

package/src/transforms/filter-query.ts

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

package/src/transforms/util/time-interval.ts

@@ -63,6 +63,10 @@ export function timeInterval(
   steps: number
 ): ({ unit: TimeUnit, step: number }) {
   const span = +max - +min;
+
+  // if degenerate span, default to one day
+  if (span === 0) return { unit: DAY, step: 1 };
+
   const t = span / steps; // target step size duration
   const i = bisect(units, t, v => v.dt);