@uwdata/mosaic-sql 0.16.2 → 0.18.0

package/src/ast/aggregate.js

@@ -1,167 +0,0 @@
-/**
- * @import { ExprVarArgs } from '../types.js'
- */
-import { AGGREGATE } from '../constants.js';
-import { asVerbatim } from '../util/ast.js';
-import { isString } from '../util/type-check.js';
-import { ExprNode } from './node.js';
-import { WindowNode } from './window.js';
-
-export class AggregateNode extends ExprNode {
-  /**
-   * Instantiate an aggregate function node.
-   * @param {string} name The aggregate function name.
-   * @param {ExprNode[]} args The aggregate function arguments.
-   * @param {boolean} [distinct] The distinct flag.
-   * @param {ExprNode} [filter] Filter expression.
-   */
-  constructor(name, args, distinct, filter) {
-    super(AGGREGATE);
-    /**
-     * The aggregate function name.
-     * @type {string}
-     * @readonly
-     */
-    this.name = name;
-    /**
-     * The aggregate function arguments.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    this.args = args;
-    /**
-     * The distinct flag.
-     * @type {boolean}
-     * @readonly
-     */
-    this.isDistinct = distinct;
-    /**
-     * Filter criteria.
-     * @type {ExprNode}
-     * @readonly
-     */
-    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(isDistinct = true) {
-    return new AggregateNode(this.name, this.args, isDistinct, 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 {...ExprVarArgs} expr The partition by criteria.
-   * @returns {WindowNode} A new window node.
-   */
-  partitionby(...expr) {
-    return this.window().partitionby(...expr);
-  }
-
-  /**
-   * Return a new window function over this aggregate with the given ordering.
-   * @param {...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, filter } = this;
-    const dist = isDistinct ? 'DISTINCT ' : '';
-    const arg = args?.length ? args.join(', ') : '*';
-    const filt = filter ? ` FILTER (WHERE ${filter})` : '';
-    return `${name}(${dist}${arg})${filt}`;
-  }
-}
-
-/**
- * An array of known aggregate function names.
- * From https://duckdb.org/docs/sql/functions/aggregates.html.
- */
-export const 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'
-];

package/src/ast/binary-op.js

@@ -1,40 +0,0 @@
-import { BINARY_OPERATOR } from '../constants.js';
-import { ExprNode } from './node.js';
-
-export class BinaryOpNode 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);
-    /**
-     * The operator type.
-     * @type {string}
-     * @readonly
-     */
-    this.op = op;
-    /**
-     * The left input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    this.left = left;
-    /**
-     * The right input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    this.right = right;
-  }
-
-  /**
-   * Generate a SQL query string for this node.
-   * @returns {string}
-   */
-  toString() {
-    return `(${this.left} ${this.op} ${this.right})`;
-  }
-}

package/src/ast/column-param.js

@@ -1,40 +0,0 @@
-/**
- * @import { ParamNode } from './param.js'
- * @import { TableRefNode } from './table-ref.js'
- */
-import { COLUMN_PARAM } from '../constants.js';
-import { ColumnRefNode } from './column-ref.js';
-
-/**
- * Check if a value is a dynamic column reference node.
- * @param {*} value The value to check.
- * @returns {value is ColumnParamNode}
- */
-export function isColumnParam(value) {
-  return value instanceof ColumnParamNode;
-}
-
-export class ColumnParamNode extends ColumnRefNode {
-  /**
-   * Instantiate a column param node.
-   * @param {ParamNode} param The column name as a parameter node.
-   * @param {TableRefNode} [table] The table reference.
-   */
-  constructor(param, table) {
-    super(COLUMN_PARAM, table);
-    /**
-     * The column name as a parameter node.
-     * @type {ParamNode}
-     * @readonly
-     */
-    this.param = param;
-  }
-
-  /**
-   * Returns the column name.
-   * @returns {string}
-   */
-  get column() {
-    return `${this.param.value}`;
-  }
-}

package/src/ast/fragment.js

@@ -1,26 +0,0 @@
-import { FRAGMENT } from '../constants.js';
-import { ExprNode } from './node.js';
-
-export class FragmentNode extends ExprNode {
-  /**
-   * Instantiate a fragment node with arbitrary content.
-   * @param {ExprNode[]} spans The consecutive parts making up the fragment.
-   */
-  constructor(spans) {
-    super(FRAGMENT);
-    /**
-     * The consecutive parts making up the fragment.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    this.spans = spans;
-  }
-
-  /**
-   * Generate a SQL query string for this node.
-   * @returns {string}
-   */
-  toString() {
-    return this.spans.join('');
-  }
-}

package/src/ast/from.js

@@ -1,40 +0,0 @@
-import { FROM_CLAUSE } from '../constants.js';
-import { quoteIdentifier } from '../util/string.js';
-import { SQLNode } from './node.js';
-import { isQuery } from './query.js';
-import { isTableRef } from './table-ref.js';
-
-export class FromClauseNode extends SQLNode {
-  /**
-   * Instantiate a from node.
-   * @param {SQLNode} expr The from expression.
-   * @param {string} alias The output name.
-   */
-  constructor(expr, alias) {
-    super(FROM_CLAUSE);
-    /**
-     * The from expression.
-     * @type {SQLNode}
-     * @readonly
-     */
-    this.expr = expr;
-    /**
-     * The output name.
-     * @type {string}
-     * @readonly
-     */
-    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}`;
-  }
-}

package/src/ast/logical-op.js

@@ -1,67 +0,0 @@
-import { LOGICAL_OPERATOR } from '../constants.js';
-import { ExprNode } from './node.js';
-
-/**
- * @template {ExprNode} T
- */
-export class LogicalOpNode 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);
-    /**
-     * The logical operator.
-     * @type {string}
-     * @readonly
-     */
-    this.op = op;
-    /**
-     * The input clause expressions.
-     * @type {T[]}
-     * @readonly
-     */
-    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} `)})`;
-  }
-}
-
-/**
- * @template {ExprNode} T
- * @extends {LogicalOpNode<T>}
- */
-export class AndNode extends LogicalOpNode {
-  /**
-   * Instantiate a logical AND operator node.
-   * @param {T[]} clauses The input clause expressions.
-   */
-  constructor(clauses) {
-    super('AND', clauses);
-  }
-}
-
-/**
- * @template {ExprNode} T
- * @extends {LogicalOpNode<T>}
- */
-export class OrNode extends LogicalOpNode {
-  /**
-   * Instantiate a logical OR operator node.
-   * @param {T[]} clauses The input clause expressions.
-   */
-  constructor(clauses) {
-    super('OR', clauses);
-  }
-}

package/src/ast/node.js

@@ -1,29 +0,0 @@
-/**
- * Check if a value is a SQL AST node.
- * @param {*} value The value to check.
- * @returns {value is SQLNode}
- */
-export function isNode(value) {
-  return value instanceof SQLNode;
-}
-
-export class SQLNode {
-  /**
-   * Instantiate a SQL AST node.
-   * @param {string} type The SQL AST node type.
-   */
-  constructor(type) {
-    /**
-     * The SQL AST node type.
-     * @type {string}
-     * @readonly
-     */
-    this.type = type;
-  }
-}
-
-/**
- * AST node corresponding to an individual expression.
- */
-export class ExprNode extends SQLNode {
-}

package/src/ast/order-by.js

@@ -1,48 +0,0 @@
-import { ORDER_BY } from '../constants.js';
-import { ExprNode } from './node.js';
-
-export class OrderByNode 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, desc, nullsFirst) {
-    super(ORDER_BY);
-    /**
-     * The expression to order by.
-     * @type {ExprNode}
-     * @readonly
-     */
-    this.expr = expr;
-    /**
-     * Flag indicating descending order.
-     * @type {boolean | undefined}
-     * @readonly
-     */
-    this.desc = desc;
-    /**
-     * Flag indicating if null values should be sorted first.
-     * @type {boolean | undefined}
-     * @readonly
-     */
-    this.nullsFirst = nullsFirst;
-  }
-
-  /**
-   * Generate a SQL query string for this node.
-   * @returns {string}
-   */
-  toString() {
-    const { expr, desc, nullsFirst } = this;
-    const dir = desc ? ' DESC'
-      : desc === false ? ' ASC'
-      : '';
-    const nf = nullsFirst ? ' NULLS FIRST'
-      : nullsFirst === false ? ' NULLS LAST'
-      : '';
-    return `${expr}${dir}${nf}`;
-  }
-}

package/src/ast/sample.js

@@ -1,53 +0,0 @@
-import { SAMPLE_CLAUSE } from '../constants.js';
-import { SQLNode } from './node.js';
-
-/**
- * @typedef {'reservoir' | 'bernoulli' | 'system'} SampleMethod
- */
-
-export class SampleClauseNode 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 = undefined, seed = undefined) {
-    super(SAMPLE_CLAUSE);
-    /**
-     * The sample size as either a row count or percentage.
-     * @type {number}
-     * @readonly
-     */
-    this.size = size;
-    /**
-     * Flag indicating if the sampling unit is rows (`false`) or a
-     * percentage (`true`).
-     * @type {boolean}
-     * @readonly
-     */
-    this.perc = perc;
-    /**
-     * The sampling method.
-     * @type {SampleMethod}
-     * @readonly
-     */
-    this.method = method;
-    /**
-     * The random seed.
-     * @type {number}
-     * @readonly
-     */
-    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})` : ''}`;
-  }
-}