@uwdata/mosaic-sql 0.16.2 → 0.17.0

package/dist/types/transforms/bin-histogram.d.ts

@@ -1,51 +0,0 @@
-/**
- * @typedef {object} BinHistogramOptions
- * @property {number} [step] An exact binning step to use.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- * @property {number} [minstep] A minimum binning step value. No generated
- *  step can be less than this value.
- * @property {boolean} [nice] A boolean flag (default true) indicating if bin
- *  extents should be snapped to "nice" numbers such as multiples of 5 or 10.
- * @property {number} [offset] The number of bin steps (default 0) by
- *  which to offset the result.
- */
-/**
- * Return a SQL expression for histogram bins.
- * @param {ExprValue} field The column or expression to bin.
- * @param {[number, number]} extent The min/max extent over which to bin.
- * @param {BinHistogramOptions} [options] Binning options.
- * @param {ReturnType<typeof scaleTransform>} [transform] Scale transforms to
- *  apply to create (potentially non-linear) binning intervals.
- * @returns {ExprNode} The resulting SQL expression
- */
-export function binHistogram(field: ExprValue, extent: [number, number], options?: BinHistogramOptions, transform?: ReturnType<typeof scaleTransform>): ExprNode;
-export type BinHistogramOptions = {
-    /**
-     * An exact binning step to use.
-     */
-    step?: number;
-    /**
-     * The desired number of binning steps.
-     * This value is a hint, it does not guarantee an exact number of steps.
-     */
-    steps?: number;
-    /**
-     * A minimum binning step value. No generated
-     * step can be less than this value.
-     */
-    minstep?: number;
-    /**
-     * A boolean flag (default true) indicating if bin
-     * extents should be snapped to "nice" numbers such as multiples of 5 or 10.
-     */
-    nice?: boolean;
-    /**
-     * The number of bin steps (default 0) by
-     * which to offset the result.
-     */
-    offset?: number;
-};
-import type { ExprValue } from '../types.js';
-import { scaleTransform } from './scales.js';
-import type { ExprNode } from '../ast/node.js';

package/dist/types/transforms/bin-linear-1d.d.ts

@@ -1,12 +0,0 @@
-/**
- * Perform linear binning in one dimension.
- * @param {SelectQuery} query The base query to bin.
- * @param {ExprValue} x The expression to bin.
- * @param {ExprValue} [weight] The expression to weight by.
- * @param {string[]} [groupby] Group by expressions.
- * @returns {Query}
- */
-export function binLinear1d(query: SelectQuery, x: ExprValue, weight?: ExprValue, groupby?: string[]): Query;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';
-import { Query } from '../ast/query.js';

package/dist/types/transforms/bin-linear-2d.d.ts

@@ -1,19 +0,0 @@
-/**
- * Compute densities over a 2D domain using linear binning. The weight of
- * each data point is linearly distributed over adjacent bins, providing
- * a better base for subsequent kernel density estimation. This method takes
- * expressions for the (non-truncated) x and y bin values; these expressions
- * should be in units of grid indices, but can contain fractional components.
- * @param {SelectQuery} q The input query. The FROM and WHERE clauses should
- *  be added to the query separately, before this method is invoked.
- * @param {ExprValue} xp The x grid bin expression
- * @param {ExprValue} yp The y grid bin expression
- * @param {ExprValue | undefined} weight Point weights.
- * @param {number} xn The number of x grid bins.
- * @param {string[]} [groupby] Group by expressions.
- * @returns {SelectQuery} A linear binning query for bin `index` and
- *  aggregate `density` columns, in addition to any group by expressions.
- */
-export function binLinear2d(q: SelectQuery, xp: ExprValue, yp: ExprValue, weight: ExprValue | undefined, xn: number, groupby?: string[]): SelectQuery;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';

package/dist/types/transforms/line-density.d.ts

@@ -1,24 +0,0 @@
-/**
- * Compute line segment densities over a gridded 2D domain. The returned
- * query uses multiple subqueries (CTEs) to identify line segment end point
- * pairs, perform line rasterization in-database, normalize arc lengths,
- * and then sum results for all line series to produce a density map.
- * Based on Moritz and Fisher's work: https://arxiv.org/abs/1808.06019
- * @param {SelectQuery} q The base query over the data.
- * @param {ExprValue} x Bin expression for x dimension.
- *  Provides gridded x coordinates, potentially with a fractional component.
- * @param {ExprValue} y Bin expression for x dimension.
- *  Provides gridded y coordinates, potentially with a fractional component.
- * @param {string[]} z Group by columns that segment data into individual line
- *  series. An empty array indicates there is only a single line series.
- * @param {number} xn The number of grid bins for the x dimension.
- * @param {number} yn The number of grid bins for the y dimension.
- * @param {string[]} [groupby] Additional group by expressions. Separate
- *  line density maps are created for each of these groups.
- * @param {boolean} [normalize=true] Flag toggling approximate arc-length
- *  normalization to improve accuracy and reduce artifacts (default `true`).
- * @returns {SelectQuery}
- */
-export function lineDensity(q: SelectQuery, x: ExprValue, y: ExprValue, z: string[], xn: number, yn: number, groupby?: string[], normalize?: boolean): SelectQuery;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';

package/dist/types/transforms/m4.d.ts

@@ -1,21 +0,0 @@
-/**
- * M4 is an optimization for value-preserving time-series aggregation
- * (https://www.vldb.org/pvldb/vol7/p797-jugel.pdf). This implementation uses
- * an efficient version with a single scan and the aggregate functions
- * argmin and argmax, following https://arxiv.org/pdf/2306.03714.pdf.
- * This method can bin along either the *x* or *y* dimension, as determined
- * by the caller-provided *bin* expression.
- * @param {FromExpr} input The base query or table.
- * @param {ExprValue} bin An expression that maps
- *  time-series values to fractional pixel positions.
- * @param {string} x The x dimension column name.
- * @param {string} y The y dimension column name.
- * @param {ExprNode[]} [groups] Additional
- *  groupby columns, for example for faceted charts.
- * @returns {Query} The resulting M4 query.
- */
-export function m4(input: FromExpr, bin: ExprValue, x: string, y: string, groups?: ExprNode[]): Query;
-import type { FromExpr } from '../types.js';
-import type { ExprValue } from '../types.js';
-import type { ExprNode } from '../ast/node.js';
-import { Query } from '../ast/query.js';

package/dist/types/transforms/scales.d.ts

@@ -1 +0,0 @@
-export function scaleTransform(options: any): any;

package/dist/types/transforms/util/bin-step.d.ts

@@ -1,61 +0,0 @@
-/**
- * @typedef {object} BinOptions
- * @property {number} [step] An exact binning step to use.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- * @property {number} [minstep] A minimum binning step value. No generated
- *  step can be less than this value.
- * @property {boolean} [nice] A boolean flag (default true) indicating if bin
- *  extents should be snapped to "nice" numbers such as multiples of 5 or 10.
- * @property {number} [base] A number indicating the the logarithm base to
- *  use for automatic step size determination. Defaults to base 10.
- */
-/**
- * Generate a numeric binning scheme suitable for a histogram.
- * @param {number} min The minimum value of the extent to bin.
- * @param {number} max The maximum value of the extent to bin.
- * @param {BinOptions} options Binning scheme options.
- */
-export function binSpec(min: number, max: number, options: BinOptions): {
-    min: number;
-    max: number;
-    steps: number;
-};
-/**
- * Determine a bin step interval.
- * @param {number} span The span from maximum to minimum value.
- * @param {number} steps The approximate number of desired bins.
- * @param {number} [minstep=0] The minimum acceptable bin step size.
- * @param {number} [logb=Math.LN10] The log base for determining
- *  orders of magnitude for step sizes. Defaults to log base 10
- *  (`Math.LN10`). For example to use log base 2, provide the
- *  argument `Math.LN2` instead.
- * @returns {number} The bin step interval (bin size).
- */
-export function binStep(span: number, steps: number, minstep?: number, logb?: number): number;
-export type BinOptions = {
-    /**
-     * An exact binning step to use.
-     */
-    step?: number;
-    /**
-     * The desired number of binning steps.
-     * This value is a hint, it does not guarantee an exact number of steps.
-     */
-    steps?: number;
-    /**
-     * A minimum binning step value. No generated
-     * step can be less than this value.
-     */
-    minstep?: number;
-    /**
-     * A boolean flag (default true) indicating if bin
-     * extents should be snapped to "nice" numbers such as multiples of 5 or 10.
-     */
-    nice?: boolean;
-    /**
-     * A number indicating the the logarithm base to
-     * use for automatic step size determination. Defaults to base 10.
-     */
-    base?: number;
-};

package/dist/types/transforms/util/time-interval.d.ts

@@ -1,13 +0,0 @@
-/**
- * Determine a time interval for binning based on provided min
- * and max timestamps and approximate step count.
- * @param {Date|number} min The minimum timestamp value.
- * @param {Date|number} max The maximum timestamp value.
- * @param {number} steps The approximate number of bins desired.
- * @returns {{ unit: TimeUnit, step: number }}
- */
-export function timeInterval(min: Date | number, max: Date | number, steps: number): {
-    unit: TimeUnit;
-    step: number;
-};
-import type { TimeUnit } from '../../types.js';

package/dist/types/types.d.ts

@@ -1,62 +0,0 @@
-import { ColumnRefNode } from './ast/column-ref.js';
-import { ExprNode, SQLNode } from './ast/node.js';
-import { TableRefNode } from './ast/table-ref.js';
-import { Query } from './ast/query.js';
-import { WithClauseNode } from './ast/with.js';
-/**
- * Interface representing a dynamic parameter value.
- */
-export interface ParamLike {
-    /** The current parameter value. */
-    value: any;
-    /** Add an event listener callback. */
-    addEventListener(type: string, callback: EventCallback): void;
-    /** Remove an event listener callback. */
-    removeEventListener(type: string, callback: EventCallback): void;
-}
-/**
- * Expression value input to SQL builder method.
- */
-export type ExprValue = ExprNode | ParamLike | string | number | boolean | Date;
-/**
- * Expression values that may be nested in arrays.
- */
-export type ExprVarArgs = MaybeArray<ExprValue>;
-/**
- * String-typed expression value.
- */
-export type StringValue = ExprNode | ParamLike | string;
-/**
- * Number-typed expression value.
- */
-export type NumberValue = ExprNode | ParamLike | number;
-/**
- * Event listener callback function.
- */
-export type EventCallback = <T>(value: any) => Promise<T> | undefined;
-/**
- * SQL AST traversal visitor callback result.
- * A falsy value (including `undefined`, `null`, `false`, and `0`) indicates
- * that traversal should continue.
- * A negative number values indicates that traversal should stop immediately.
- * Any other truthy value indicates that traversal should not recurse on the
- * current node, but should otherwise continue.
- */
-export type VisitorResult = boolean | number | null | undefined | void;
-/**
- * SQL AST traversal callback function.
- */
-export type VisitorCallback = (node: SQLNode) => VisitorResult;
-/** Valid window function names. */
-export type WindowFunctionName = 'cume_dist' | 'dense_rank' | 'first_value' | 'lag' | 'last_value' | 'lead' | 'nth_value' | 'ntile' | 'percent_rank' | 'rank_dense' | 'rank' | 'row_number';
-export type MaybeArray<T> = T | T[];
-export type SelectEntry = string | ColumnRefNode | [string, ExprNode] | Record<string, ExprValue>;
-export type SelectExpr = MaybeArray<SelectEntry>;
-export type WithEntry = WithClauseNode | Record<string, Query>;
-export type WithExpr = MaybeArray<WithEntry>;
-export type FromEntry = string | TableRefNode | SQLNode | [string, SQLNode] | Record<string, string | SQLNode>;
-export type FromExpr = MaybeArray<FromEntry>;
-export type FilterExpr = MaybeArray<string | ExprNode>;
-export type GroupByExpr = MaybeArray<string | ExprNode>;
-export type OrderByExpr = MaybeArray<string | ExprNode>;
-export type TimeUnit = 'year' | 'quarter' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond';

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

@@ -1,61 +0,0 @@
-/**
- * Interpret a value as a SQL AST node. String values are assumed to be
- * column references. All other primitive values are interpreted as
- * SQL literals. Dynamic parameters are interpreted as param AST nodes,
- * while existing AST nodes are left as-is.
- * @param {*} value The value to interpret as a SQL AST node.
- * @returns {ExprNode}
- */
-export function asNode(value: any): ExprNode;
-/**
- * Interpret a value as a verbatim SQL AST node. String values will be
- * passed through to queries as verbatim text. All other primitive values
- * are interpreted as SQL literals. Dynamic parameters are interpreted
- * as param AST nodes, while existing AST nodes are left as-is.
- * @param {*} value The value to interpret as a verbatim AST node.
- * @returns {ExprNode}
- */
-export function asVerbatim(value: any): ExprNode;
-/**
- * Interpret a value as a literal AST node. All other primitive values
- * are interpreted as SQL literals. Dynamic parameters are interpreted
- * as param AST nodes, while existing AST nodes are left as-is.
- * @param {*} value The value to interpret as a literal AST node.
- * @returns {ExprNode}
- */
-export function asLiteral(value: any): ExprNode;
-/**
- * Interpret a value as a table reference AST node. String values are parsed
- * assuming dot ('.') delimiters (as in `schema.table`). Array values are
- * interpreted as pre-parsed name paths (as in `['schema', 'table']`). Any
- * other values are left as-is.
- * @param {string | string[] | TableRefNode} value The value to interpret as a
- *  table reference AST node.
- * @returns {TableRefNode}
- */
-export function asTableRef(value: string | string[] | TableRefNode): TableRefNode;
-/**
- * Parse a string as a column reference, potentially with
- * dot ('.') delimited table, schema, and database references.
- * @param {string} ref The column reference string.
- * @returns {ColumnRefNode}
- */
-export function parseColumnRef(ref: string): ColumnRefNode;
-/**
- * Parse a string as a table reference, potentially with
- * dot ('.') delimited schema and database references.
- * @param {string} ref The table reference string.
- * @returns {TableRefNode}
- */
-export function parseTableRef(ref: string): TableRefNode;
-/**
- * Create a new window definition node. The return value is an empty
- * window definition. Use chained calls such as `partitionby` and `orderby`
- * to specify the window settings.
- * @returns {WindowDefNode}
- */
-export function over(): WindowDefNode;
-import { ExprNode } from '../ast/node.js';
-import type { TableRefNode } from '../ast/table-ref.js';
-import type { ColumnRefNode } from '../ast/column-ref.js';
-import { WindowDefNode } from '../ast/window.js';

package/dist/types/util/function.d.ts

@@ -1,56 +0,0 @@
-/**
- * Test if an AST node is a specific function call.
- * @param {SQLNode} node The SQL AST node to test.
- * @param {string} name The function name.
- * @returns {node is FunctionNode}
- */
-export function isFunctionCall(node: SQLNode, name: string): node is FunctionNode;
-/**
- * Create a new function call AST node.
- * @param {string} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {FunctionNode}
- */
-export function fn(name: string, ...args: any[]): FunctionNode;
-/**
- * Create a new aggregate function AST node.
- * @param {string} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {AggregateNode}
- */
-export function aggFn(name: string, ...args: any[]): AggregateNode;
-/**
- * Create a new window AST node. The output node has an empty window
- * definition. Use chained calls such as `partitionby` and `orderby`
- * to specify the window settings.
- * @param {WindowFunctionName} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {WindowNode}
- */
-export function winFn(name: WindowFunctionName, ...args: any[]): WindowNode;
-/**
- * Process a list of expression inputs. Nested arrays are flattened,
- * null results are removed, and each input is cast (as needed) to
- * be a proper SQL AST node. By default, strings are assumed to be
- * column names, while other primitive values map to SQL literals.
- * Use an alternative *cast* function to change this behavior.
- * @param {any[]} list The list of expression inputs.
- * @param {function} [cast] A function that casts an input value
- *  to a desired type. By default, `asNode` is used to coerce
- *  inputs to AST nodes as needed.
- * @returns {ReturnType<cast>[]}
- */
-export function exprList(list: any[], cast?: Function): ReturnType<Function>[];
-/**
- * Process a list of function arguments, stripping any undefined
- * values from the end of the list.
- * @template T
- * @param {T[]} list The input function arguments.
- * @returns {T[]} The prepared argument list.
- */
-export function argsList<T>(list: T[]): T[];
-import type { SQLNode } from '../ast/node.js';
-import { FunctionNode } from '../ast/function.js';
-import { AggregateNode } from '../ast/aggregate.js';
-import type { WindowFunctionName } from '../types.js';
-import { WindowNode } from '../ast/window.js';

package/dist/types/util/string.d.ts

@@ -1,3 +0,0 @@
-export function parseIdentifier(id: any): any;
-export function quoteIdentifier(value: any): string;
-export function unquote(s: any): any;

package/dist/types/util/type-check.d.ts

@@ -1,22 +0,0 @@
-/**
- * @import { ParamLike } from '../types.js'
- */
-/**
- * Check if a value is a string.
- * @param {*} value The value to check.
- * @returns {value is string}
- */
-export function isString(value: any): value is string;
-/**
- * Check if a value is an array.
- * @param {*} value The value to check.
- * @returns {value is Array}
- */
-export function isArray(value: any): value is any[];
-/**
- * Check if a value is a dynamic parameter.
- * @param {*} value The value to check.
- * @returns {value is ParamLike}
- */
-export function isParamLike(value: any): value is ParamLike;
-import type { ParamLike } from '../types.js';

package/dist/types/visit/recurse.d.ts

@@ -1,28 +0,0 @@
-export namespace recurse {
-    let AGGREGATE: string[];
-    let BETWEEN: string[];
-    let BINARY: string[];
-    let CASE: string[];
-    let CAST: string[];
-    let COLUMN_PARAM: string[];
-    let COLUMN_REF: string[];
-    let DESCRIBE_QUERY: string[];
-    let EXPRESSION: string[];
-    let FRAGMENT: string[];
-    let FROM_CLAUSE: string[];
-    let FUNCTION: string[];
-    let IN: string[];
-    let LOGICAL_OPERATOR: string[];
-    let NOT_BETWEEN: string[];
-    let ORDER_BY: string[];
-    let PARAM: string[];
-    let SELECT_CLAUSE: string[];
-    let SELECT_QUERY: string[];
-    let SET_OPERATION: string[];
-    let UNARY: string[];
-    let WHEN: string[];
-    let WINDOW: string[];
-    let WINDOW_CLAUSE: string[];
-    let WINDOW_DEF: string[];
-    let WINDOW_FRAME: string[];
-}

package/dist/types/visit/rewrite.d.ts

@@ -1,10 +0,0 @@
-/**
- * Rewrite a SQL expression, based on a map of nodes to replace.
- * This method copies nodes as needed; it does not modify the input node.
- * @param {ExprNode} node The root AST node of the expression.
- * @param {Map<ExprNode, ExprNode>} map The rewrite map.
- *  When encountered, key nodes are replaced by value nodes.
- * @returns {ExprNode}
- */
-export function rewrite(node: ExprNode, map: Map<ExprNode, ExprNode>): ExprNode;
-import type { ExprNode } from '../ast/node.js';

package/dist/types/visit/visitors.d.ts

@@ -1,34 +0,0 @@
-/**
- * Indicate if the input AST contains an aggregate expression.
- * The string content of verbatim nodes is analyzed to try to identify
- * unparsed aggregate functions calls within SQL strings.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {number} Return 0 if no aggregate functions are found.
- *  Sets bit 1 if an AggregateFunction instance is found.
- *  Sets bit 2 if an aggregate embedded in verbatim text is found.
- */
-export function isAggregateExpression(root: SQLNode): number;
-/**
- * Collect all aggregate function nodes.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {AggregateNode[]}
- */
-export function collectAggregates(root: SQLNode): AggregateNode[];
-/**
- * Collect all unique column references.
- * Multiple references to the same column are de-duplicated, even if
- * they are not object-equal node instances.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {ColumnRefNode[]}
- */
-export function collectColumns(root: SQLNode): ColumnRefNode[];
-/**
- * Collect all unique dynamic parameter instances.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {ParamLike[]}
- */
-export function collectParams(root: SQLNode): ParamLike[];
-import type { SQLNode } from '../ast/node.js';
-import type { AggregateNode } from '../ast/aggregate.js';
-import type { ColumnRefNode } from '../ast/column-ref.js';
-import type { ParamLike } from '../types.js';

package/dist/types/visit/walk.d.ts

@@ -1,10 +0,0 @@
-/**
- * Perform a traversal of a SQL expression AST.
- * @param {SQLNode} node Root node for AST traversal.
- * @param {VisitorCallback} visit Visitor callback function.
- * @return {VisitorResult}
- */
-export function walk(node: SQLNode, visit: VisitorCallback): VisitorResult;
-import type { SQLNode } from '../ast/node.js';
-import type { VisitorCallback } from '../types.js';
-import type { VisitorResult } from '../types.js';

package/jsconfig.json

@@ -1,11 +0,0 @@
-{
-  "include": ["src/**/*"],
-  "compilerOptions": {
-    "checkJs": true,
-    "noEmit": true,
-    "noImplicitAny": false,
-    "module": "node16",
-    "skipLibCheck": true,
-    "types": []
-  }
-}