@uwdata/mosaic-sql 0.16.2 → 0.17.0

package/dist/types/ast/with.d.ts

@@ -1,32 +0,0 @@
-export class WithClauseNode 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.
-     * @param {boolean | null} [materialized] The common table expression (CTE)
-     *  materialization flag. If `true`, forces materialization of the CTE.
-     *  If `false`, materialization is not performed. Otherwise (for example, if
-     *  `undefined` or `null`), materialization is decided by the database.
-     */
-    constructor(name: string, query: Query, materialized?: boolean | null);
-    /**
-     * The common table expression (CTE) name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The common table expression (CTE) query.
-     * @type {Query}
-     * @readonly
-     */
-    readonly query: Query;
-    /**
-     * The common table expression (CTE) materialization flag.
-     * @type {boolean | null}
-     * @readonly
-     */
-    readonly materialized: boolean | null;
-}
-import { SQLNode } from './node.js';
-import type { Query } from './query.js';

package/dist/types/constants.d.ts

@@ -1,38 +0,0 @@
-export const COLUMN_REF: "COLUMN_REF";
-export const COLUMN_PARAM: "COLUMN_PARAM";
-export const TABLE_REF: "TABLE_REF";
-export const LITERAL: "LITERAL";
-export const INTERVAL: "INTERVAL";
-export const ORDER_BY: "ORDER_BY";
-export const CAST: "CAST";
-export const CASE: "CASE";
-export const WHEN: "WHEN";
-export const UNARY_OPERATOR: "UNARY";
-export const UNARY_POSTFIX_OPERATOR: "UNARY_POSTFIX";
-export const BINARY_OPERATOR: "BINARY";
-export const BETWEEN_OPERATOR: "BETWEEN";
-export const NOT_BETWEEN_OPERATOR: "NOT_BETWEEN";
-export const LOGICAL_OPERATOR: "LOGICAL_OPERATOR";
-export const IN_OPERATOR: "IN";
-export const FUNCTION: "FUNCTION";
-export const AGGREGATE: "AGGREGATE";
-export const WINDOW: "WINDOW";
-export const WINDOW_DEF: "WINDOW_DEF";
-export const WINDOW_FRAME: "WINDOW_FRAME";
-export const EXPRESSION: "EXPRESSION";
-export const FRAGMENT: "FRAGMENT";
-export const VERBATIM: "VERBATIM";
-export const PARAM: "PARAM";
-export const WITH_CLAUSE: "WITH_CLAUSE";
-export const SELECT_CLAUSE: "SELECT_CLAUSE";
-export const FROM_CLAUSE: "FROM_CLAUSE";
-export const WHERE_CLAUSE: "WHERE_CLAUSE";
-export const SAMPLE_CLAUSE: "SAMPLE_CLAUSE";
-export const GROUPBY_CLAUSE: "GROUPBY_CLAUSE";
-export const HAVING_CLAUSE: "HAVING_CLAUSE";
-export const WINDOW_CLAUSE: "WINDOW_CLAUSE";
-export const QUALIFY_CLAUSE: "QUALIFY_CLAUSE";
-export const ORDERBY_CLAUSE: "ORDERBY_CLAUSE";
-export const SELECT_QUERY: "SELECT_QUERY";
-export const DESCRIBE_QUERY: "DESCRIBE_QUERY";
-export const SET_OPERATION: "SET_OPERATION";

package/dist/types/functions/aggregate.d.ts

@@ -1,236 +0,0 @@
-/**
- * Compute an arg_max aggregate.
- * @param {ExprValue} y The argument to return.
- * @param {ExprValue} x The expression to maximize.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function argmax(y: ExprValue, x: ExprValue): AggregateNode;
-/**
- * Compute an arg_min aggregate.
- * @param {ExprValue} y The argument to return.
- * @param {ExprValue} x The expression to minimize.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function argmin(y: ExprValue, x: ExprValue): AggregateNode;
-/**
- * Compute an array aggregation.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function arrayAgg(expr: ExprValue): AggregateNode;
-/**
- * Compute an average aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function avg(expr: ExprValue): AggregateNode;
-/**
- * Compute a correlation aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function corr(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a count aggregate.
- * @param {ExprValue} [expr] An optional expression
- *  to count. If specified, only non-null expression values are counted.
- *  If omitted, all rows within a group are counted.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function count(expr?: ExprValue): AggregateNode;
-/**
- * Compute a sample covariance aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function covariance(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a population covariance aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function covarPop(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute an entropy aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function entropy(expr: ExprValue): AggregateNode;
-/**
- * Compute a first aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function first(expr: ExprValue): AggregateNode;
-/**
- * Compute a geomean aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function geomean(expr: ExprValue): AggregateNode;
-/**
- * Compute a sample kurtosis aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function kurtosis(expr: ExprValue): AggregateNode;
-/**
- * Compute a median absolute deviation (MAD) aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function mad(expr: ExprValue): AggregateNode;
-/**
- * Compute a maximum aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function max(expr: ExprValue): AggregateNode;
-/**
- * Compute a median aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function median(expr: ExprValue): AggregateNode;
-/**
- * Compute a minimum aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function min(expr: ExprValue): AggregateNode;
-/**
- * Compute a mode aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function mode(expr: ExprValue): AggregateNode;
-/**
- * Compute a last aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function last(expr: ExprValue): AggregateNode;
-/**
- * Compute a product aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function product(expr: ExprValue): AggregateNode;
-/**
- * Compute a quantile aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @param {ExprValue} p The quantile value.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function quantile(expr: ExprValue, p: ExprValue): AggregateNode;
-/**
- * Compute a linear regression reg_avgX aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrAvgX(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression reg_avgY aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrAvgY(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression count aggregate.
- * This returns the count of rows where both x and y are non-null.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrCount(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression intercept aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrIntercept(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression R^2 aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrR2(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression regr_sxx aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrSXX(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression regr_sxy aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrSXY(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression regr_syy aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrSYY(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a linear regression slope aggregate.
- * @param {ExprValue} x The x expression to aggregate.
- * @param {ExprValue} y The y expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function regrSlope(x: ExprValue, y: ExprValue): AggregateNode;
-/**
- * Compute a skewness aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function skewness(expr: ExprValue): AggregateNode;
-/**
- * Compute a sample standard deviation aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function stddev(expr: ExprValue): AggregateNode;
-/**
- * Compute a population standard deviation aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function stddevPop(expr: ExprValue): AggregateNode;
-/**
- * Compute a string aggregation.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function stringAgg(expr: ExprValue): AggregateNode;
-/**
- * Compute a sum aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function sum(expr: ExprValue): AggregateNode;
-/**
- * Compute a sample variance aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function variance(expr: ExprValue): AggregateNode;
-/**
- * Compute a population variance aggregate.
- * @param {ExprValue} expr The expression to aggregate.
- * @returns {AggregateNode} A SQL aggregate function call.
- */
-export function varPop(expr: ExprValue): AggregateNode;
-import type { ExprValue } from '../types.js';
-import type { AggregateNode } from '../ast/aggregate.js';

package/dist/types/functions/case.d.ts

@@ -1,13 +0,0 @@
-/**
- * Create a new conditional CASE statement. If three arguments are provided,
- * acts like a ternary conditional (if, then, else). If no arguments are
- * provided, the chained `when` and `else` methods can be used to to complete
- * a conditional statement with WHEN/THEN and ELSE expressions.
- * @param {ExprValue} [when] A conditional WHEN expression.
- * @param {ExprValue} [then] A THEN value expression.
- * @param {ExprValue} [other] An ELSE expression.
- * @returns {CaseNode}
- */
-export function cond(when?: ExprValue, then?: ExprValue, other?: ExprValue): CaseNode;
-import type { ExprValue } from '../types.js';
-import { CaseNode } from '../ast/case.js';

package/dist/types/functions/cast.d.ts

@@ -1,26 +0,0 @@
-/**
- * Perform a type cast.
- * @param {*} expr The expression to type cast.
- * @param {string} type The type to cast to.
- * @returns {CastNode}
- */
-export function cast(expr: any, type: string): CastNode;
-/**
- * Cast an expression to a 32-bit integer type.
- * @param {*} expr The expression to type cast.
- * @returns {CastNode}
- */
-export function int32(expr: any): CastNode;
-/**
- * Cast an expression to a 32-bit floating point number type.
- * @param {*} expr The expression to type cast.
- * @returns {CastNode}
- */
-export function float32(expr: any): CastNode;
-/**
- * Cast an expression to a 64-bit floating point number type.
- * @param {*} expr The expression to type cast.
- * @returns {CastNode}
- */
-export function float64(expr: any): CastNode;
-import { CastNode } from '../ast/cast.js';

package/dist/types/functions/column.d.ts

@@ -1,11 +0,0 @@
-/**
- * Create a column reference.
- * @param {string | ParamLike} name The column name,
- *  as a string or as a dynamic parameter.
- * @param {string | string[] | TableRefNode} [table] The table reference.
- * @returns {ColumnRefNode}
- */
-export function column(name: string | ParamLike, table?: string | string[] | TableRefNode): ColumnRefNode;
-import type { ParamLike } from '../types.js';
-import type { TableRefNode } from '../ast/table-ref.js';
-import type { ColumnRefNode } from '../ast/column-ref.js';

package/dist/types/functions/cte.d.ts

@@ -1,13 +0,0 @@
-/**
- * Create a common table expression (CTE) to include within a WITH clause.
- * @param {string} name The common table expression (CTE) name.
- * @param {Query} query The common table expression (CTE) query.
- * @param {boolean | null} [materialized] The common table expression (CTE)
- *  materialization flag. If `true`, forces materialization of the CTE.
- *  If `false`, materialization is not performed. Otherwise (for example, if
- *  `undefined` or `null`), materialization is decided by the database.
- * @returns {WithClauseNode}
- */
-export function cte(name: string, query: Query, materialized?: boolean | null): WithClauseNode;
-import type { Query } from '../ast/query.js';
-import { WithClauseNode } from '../ast/with.js';

package/dist/types/functions/datetime.d.ts

@@ -1,45 +0,0 @@
-/**
- * Create a new interval.
- * @param {string} unit The interval unit, such as day or year.
- * @param {number} steps The number interval unit steps.
- * @returns {IntervalNode}
- */
-export function interval(unit: string, steps: number): IntervalNode;
-/**
- * Given a date/time value, return the milliseconds since the UNIX epoch.
- * @param {ExprValue} expr The date/time expression.
- * @returns {FunctionNode}
- */
-export function epoch_ms(expr: ExprValue): FunctionNode;
-/**
- * Perform data binning according to the provided interval unit and steps.
- * @param {ExprValue} expr The date/time expression to bin.
- * @param {string} unit The datetime interval unit to bin by.
- * @param {number} [steps=1] The number of interval steps.
- * @returns {FunctionNode}
- */
-export function dateBin(expr: ExprValue, unit: string, steps?: number): FunctionNode;
-/**
- * Map date/times to a month value, all within the same year for comparison.
- * The resulting value is still date-typed.
- * @param {ExprValue} expr The date/time expression.
- * @returns {FunctionNode}
- */
-export function dateMonth(expr: ExprValue): FunctionNode;
-/**
- * Map date/times to a month and day value, all within the same year for
- * comparison. The resulting value is still date-typed.
- * @param {ExprValue} expr The date/time expression.
- * @returns {FunctionNode}
- */
-export function dateMonthDay(expr: ExprValue): FunctionNode;
-/**
- * Map date/times to a day of the month value, all within the same year and month
- * for comparison. The resulting value is still date-typed.
- * @param {ExprValue} expr The date/time expression.
- * @returns {FunctionNode}
- */
-export function dateDay(expr: ExprValue): FunctionNode;
-import { IntervalNode } from '../ast/interval.js';
-import type { ExprValue } from '../types.js';
-import type { FunctionNode } from '../ast/function.js';

package/dist/types/functions/literal.d.ts

@@ -1,16 +0,0 @@
-/**
- * Return a SQL AST node for a literal value. The supported types are
- * null, string, number, boolean, Date, and RegExp. Otherwise, the
- * input value will be directly coerced to a string.
- * @param {*} value The literal value.
- * @returns {LiteralNode}
- */
-export function literal(value: any): LiteralNode;
-/**
- * Return a SQL AST node for verbatim string content.
- * @param {string} value The verbatim value.
- * @returns {VerbatimNode}
- */
-export function verbatim(value: string): VerbatimNode;
-import { LiteralNode } from '../ast/literal.js';
-import { VerbatimNode } from '../ast/verbatim.js';

package/dist/types/functions/numeric.d.ts

@@ -1,95 +0,0 @@
-/**
- * Return true if the floating point value is not a number, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isNaN(expr: ExprValue): FunctionNode;
-/**
- * Return true if the floating point value is finite, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isFinite(expr: ExprValue): FunctionNode;
-/**
- * Return true if the floating point value is infinite, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isInfinite(expr: ExprValue): FunctionNode;
-/**
- * Selects the largest value.
- * @param {...ExprValue} expr The input expressions.
- * @returns {FunctionNode}
- */
-export function greatest(...expr: ExprValue[]): FunctionNode;
-/**
- * Selects the smallest value.
- * @param {...ExprValue} expr The input expressions.
- * @returns {FunctionNode}
- */
-export function least(...expr: ExprValue[]): FunctionNode;
-/**
- * Compute the exponentional function `e ** expr`.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function exp(expr: ExprValue): FunctionNode;
-/**
- * Compute a base 10 logarithm.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function log(expr: ExprValue): FunctionNode;
-/**
- * Compute a natural logarithm.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function ln(expr: ExprValue): FunctionNode;
-/**
- * Compute the sign of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function sign(expr: ExprValue): FunctionNode;
-/**
- * Compute the absolute value of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function abs(expr: ExprValue): FunctionNode;
-/**
- * Compute the square root of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function sqrt(expr: ExprValue): FunctionNode;
-/**
- * Rounds the number up.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function ceil(expr: ExprValue): FunctionNode;
-/**
- * Rounds the number down.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function floor(expr: ExprValue): FunctionNode;
-/**
- * Round to the given decimal places.
- * @param {ExprValue} expr The input number.
- * @param {ExprValue} [places] The decimal places.
- *  Negative values are allowed, to round to tens, hundreds, etc.
- *  If unspecified, defaults to zero.
- * @returns {FunctionNode}
- */
-export function round(expr: ExprValue, places?: ExprValue): FunctionNode;
-/**
- * Truncates the number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function trunc(expr: ExprValue): FunctionNode;
-import type { ExprValue } from '../types.js';
-import type { FunctionNode } from '../ast/function.js';