@uwdata/mosaic-sql 0.16.2 → 0.18.0

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

@@ -1,320 +0,0 @@
-/**
- * Check if a value is a selection query or set operation.
- * @param {*} value The value to check.
- * @returns {value is Query}
- */
-export function isQuery(value: any): value is Query;
-/**
- * Check if a value is a selection query.
- * @param {*} value The value to check.
- * @returns {value is SelectQuery}
- */
-export function isSelectQuery(value: any): value is SelectQuery;
-/**
- * Check if a value is a describe query.
- * @param {*} value The value to check.
- * @returns {value is DescribeQuery}
- */
-export function isDescribeQuery(value: any): value is DescribeQuery;
-export class Query extends ExprNode {
-    /**
-     * Create a new WITH clause with the given CTE queries.
-     * @param {...WithExpr} expr The WITH CTE queries.
-     * @returns {WithClause}
-     */
-    static with(...expr: WithExpr[]): WithClause;
-    /**
-     * Create a new select query with the given SELECT expressions.
-     * @param {...SelectExpr} expr The SELECT expressions.
-     * @returns {SelectQuery}
-     */
-    static select(...expr: SelectExpr[]): SelectQuery;
-    /**
-     * Create a new select query with the given FROM expressions.
-     * @param {...FromExpr} expr The FROM expressions.
-     * @returns {SelectQuery}
-     */
-    static from(...expr: FromExpr[]): SelectQuery;
-    /**
-     * Create a new UNION set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    static union(...queries: Query[]): SetOperation;
-    /**
-     * Create a new UNION ALL set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    static unionAll(...queries: Query[]): SetOperation;
-    /**
-     * Create a new INTERSECT set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    static intersect(...queries: Query[]): SetOperation;
-    /**
-     * Create a new EXCEPT set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    static except(...queries: Query[]): SetOperation;
-    /**
-     * Create a new describe query for the given input query.
-     * @param {Query} query The query to describe.
-     * @returns {DescribeQuery}
-     */
-    static describe(query: Query): DescribeQuery;
-    /**
-     * Instantiate a new query.
-     */
-    constructor(type: any);
-    /** @type {WithClauseNode[]} */
-    _with: WithClauseNode[];
-    /** @type {ExprNode[]} */
-    _orderby: ExprNode[];
-    /** @type {number} */
-    _limit: number;
-    /** @type {number} */
-    _offset: number;
-    /** @type {Query | null} */
-    cteFor: Query | null;
-    /**
-     * Return a list of subqueries.
-     * @returns {Query[]}
-     */
-    get subqueries(): Query[];
-    /**
-     * Clone this query.
-     * @returns {Query}
-     */
-    clone(): Query;
-    /**
-     * Add WITH common table expressions (CTEs).
-     * @param  {...WithExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    with(...expr: WithExpr[]): this;
-    /**
-     * Add ORDER BY expressions.
-     * @param  {...OrderByExpr} expr Expressions to add.
-     * @returns
-     */
-    orderby(...expr: OrderByExpr[]): this;
-    /**
-     * Set the query result LIMIT.
-     * @param {number} value The limit value.
-     * @returns {this}
-     */
-    limit(value: number): this;
-    /**
-     * Set the query result OFFSET.
-     * @param {number} value The offset value.
-     * @returns {this}
-     */
-    offset(value: number): this;
-}
-export class SelectQuery extends Query {
-    /**
-     * Instantiate a new select query.
-     */
-    constructor();
-    /** @type {SelectClauseNode[]} */
-    _select: SelectClauseNode[];
-    /** @type {FromClauseNode[]} */
-    _from: FromClauseNode[];
-    /** @type {ExprNode[]} */
-    _where: ExprNode[];
-    /** @type {SampleClauseNode} */
-    _sample: SampleClauseNode;
-    /** @type {ExprNode[]} */
-    _groupby: ExprNode[];
-    /** @type {ExprNode[]} */
-    _having: ExprNode[];
-    /** @type {WindowClauseNode[]} */
-    _window: WindowClauseNode[];
-    /** @type {ExprNode[]} */
-    _qualify: ExprNode[];
-    /**
-     * Clone this query.
-     * @returns {SelectQuery}
-     */
-    clone(): SelectQuery;
-    /**
-     * Add SELECT expressions.
-     * @param {...SelectExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    select(...expr: SelectExpr[]): this;
-    /**
-     * Set SELECT expressions, replacing any prior expressions.
-     * @param {...SelectExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    setSelect(...expr: SelectExpr[]): this;
-    /**
-     * Indicate if this query should retrieve distinct values only.
-     * @param {boolean} value The distinct flag
-     * @returns {this}
-     */
-    distinct(value?: boolean): this;
-    _distinct: boolean;
-    /**
-     * Add table FROM expressions.
-     * @param  {...FromExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    from(...expr: FromExpr[]): this;
-    /**
-     * Set FROM expressions, replacing any prior expressions.
-     * @param {...FromExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    setFrom(...expr: FromExpr[]): this;
-    /**
-     * Set SAMPLE settings.
-     * @param {number | SampleClauseNode} value Either a sample clause node
-     *  or the sample size as either a row count or percentage.
-     * @param {SampleMethod} [method] The sampling method
-     *  to use.
-     * @param {number} [seed] The random seed.
-     * @returns {this}
-     */
-    sample(value: number | SampleClauseNode, method?: SampleMethod, seed?: number): this;
-    /**
-     * Add WHERE expressions.
-     * @param  {...FilterExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    where(...expr: FilterExpr[]): this;
-    /**
-     * Set WHERE expressions, replacing any prior expressions.
-     * @param {...FilterExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    setWhere(...expr: FilterExpr[]): this;
-    /**
-     * Add GROUP BY expressions.
-     * @param  {...GroupByExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    groupby(...expr: GroupByExpr[]): this;
-    /**
-     * Set GROUP BY expressions, replacing any prior expressions.
-     * @param {...GroupByExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    setGroupby(...expr: GroupByExpr[]): this;
-    /**
-     * Add HAVING expressions.
-     * @param {...FilterExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    having(...expr: FilterExpr[]): this;
-    /**
-     * Add WINDOW definitions.
-     * @param  {...any} expr Expressions to add.
-     * @returns {this}
-     */
-    window(...expr: any[]): this;
-    /**
-     * Add QUALIFY expressions.
-     * @param {...FilterExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    qualify(...expr: FilterExpr[]): this;
-}
-export class DescribeQuery extends SQLNode {
-    /**
-     * Instantiate a describe query.
-     */
-    constructor(query: any);
-    query: any;
-    /**
-     * Clone this describe query.
-     * @returns {DescribeQuery}
-     */
-    clone(): DescribeQuery;
-}
-export class SetOperation extends Query {
-    /**
-     * Instantiate a new set operation instance.
-     * @param {string} op The set operation.
-     * @param {Query[]} queries The subqueries.
-     */
-    constructor(op: string, queries: Query[]);
-    /**
-     * @type {string}
-     * @readonly
-     */
-    readonly op: string;
-    /**
-     * @type {Query[]}
-     * @readonly
-     */
-    readonly queries: Query[];
-    /**
-     * Clone this set operation.
-     * @returns {SetOperation}
-     */
-    clone(): SetOperation;
-}
-import { ExprNode } from './node.js';
-import { WithClauseNode } from './with.js';
-import type { WithExpr } from '../types.js';
-import type { OrderByExpr } from '../types.js';
-declare class WithClause {
-    /**
-     * Instantiate a new WITH clause instance.
-     * @param {...WithExpr} expr The WITH CTE queries.
-     */
-    constructor(...expr: WithExpr[]);
-    _with: WithExpr[];
-    /**
-     * Create a new select query with the given SELECT expressions.
-     * @param {...SelectExpr} expr The SELECT expressions.
-     * @returns {SelectQuery}
-     */
-    select(...expr: SelectExpr[]): SelectQuery;
-    /**
-     * Create a new select query with the given FROM expressions.
-     * @param {...FromExpr} expr The FROM expressions.
-     * @returns {SelectQuery}
-     */
-    from(...expr: FromExpr[]): SelectQuery;
-    /**
-     * Create a new UNION set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    union(...queries: Query[]): SetOperation;
-    /**
-     * Create a new UNION ALL set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    unionAll(...queries: Query[]): SetOperation;
-    /**
-     * Create a new INTERSECT set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    intersect(...queries: Query[]): SetOperation;
-    /**
-     * Create a new EXCEPT set operation over the given queries.
-     * @param {...Query} queries The queries.
-     * @returns {SetOperation}
-     */
-    except(...queries: Query[]): SetOperation;
-}
-import type { SelectExpr } from '../types.js';
-import type { FromExpr } from '../types.js';
-import { SelectClauseNode } from './select.js';
-import { FromClauseNode } from './from.js';
-import { SampleClauseNode } from './sample.js';
-import { WindowClauseNode } from './window.js';
-import type { SampleMethod } from './sample.js';
-import type { FilterExpr } from '../types.js';
-import type { GroupByExpr } from '../types.js';
-import { SQLNode } from './node.js';
-export {};

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

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

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

@@ -1,22 +0,0 @@
-export class SelectClauseNode extends SQLNode {
-    /**
-     * Instantiate a select node.
-     * @param {ExprNode} expr The select expression.
-     * @param {string} alias The output name.
-     */
-    constructor(expr: ExprNode, alias: string);
-    /**
-     * The select expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * The output name.
-     * @type {string}
-     * @readonly
-     */
-    readonly alias: string;
-}
-import { SQLNode } from './node.js';
-import type { ExprNode } from './node.js';

package/dist/types/ast/table-ref.d.ts

@@ -1,25 +0,0 @@
-/**
- * Check if a value is a table reference node.
- * @param {*} value The value to check.
- * @returns {value is TableRefNode}
- */
-export function isTableRef(value: any): value is TableRefNode;
-export class TableRefNode extends ExprNode {
-    /**
-     * Instantiate a table reference node.
-     * @param {string | string[]} table The table name.
-     */
-    constructor(table: string | string[]);
-    /**
-     * The table name, including namespaces.
-     * @type {string[]}
-     * @readonly
-     */
-    readonly table: string[];
-    /**
-     * The table name without database or schema namespaces.
-     * @returns {string}
-     */
-    get name(): string;
-}
-import { ExprNode } from './node.js';

package/dist/types/ast/unary-op.d.ts

@@ -1,39 +0,0 @@
-export class UnaryOpNode extends AbstractUnaryOpNode {
-    /**
-     * Instantiate a unary operator node.
-     * @param {string} op The operator type.
-     * @param {ExprNode} expr The input expression.
-     */
-    constructor(op: string, expr: ExprNode);
-}
-export class UnaryPosftixOpNode extends AbstractUnaryOpNode {
-    /**
-     * Instantiate a unary operator node.
-     * @param {string} op The operator type.
-     * @param {ExprNode} expr The input expression.
-     */
-    constructor(op: string, expr: ExprNode);
-}
-declare class AbstractUnaryOpNode 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: string, op: string, expr: ExprNode);
-    /**
-     * The operator type.
-     * @type {string}
-     * @readonly
-     */
-    readonly op: string;
-    /**
-     * The input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-}
-import { ExprNode } from './node.js';
-export {};

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

@@ -1,9 +0,0 @@
-export class VerbatimNode extends ExprNode {
-    /**
-     * The verbatim content to include.
-     * @type {string}
-     * @readonly
-     */
-    readonly value: string;
-}
-import { ExprNode } from './node.js';

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

@@ -1,180 +0,0 @@
-/**
- * @typedef {[any, any] | ParamLike} FrameExtent
- */
-export class WindowClauseNode extends SQLNode {
-    /**
-     * Instantiate a window clause node.
-     * @param {string} name The window name.
-     * @param {WindowDefNode} def The window definition.
-     */
-    constructor(name: string, def: WindowDefNode);
-    /**
-     * The window name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The window definition.
-     * @type {WindowDefNode}
-     * @readonly
-     */
-    readonly def: WindowDefNode;
-}
-export 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: WindowFunctionNode | AggregateNode, over?: WindowDefNode);
-    /**
-     * @type {WindowFunctionNode | AggregateNode}
-     * @readonly
-     */
-    readonly func: WindowFunctionNode | AggregateNode;
-    /**
-     * @type {WindowDefNode}
-     * @readonly
-     */
-    readonly def: WindowDefNode;
-    /**
-     * Return an updated window over a named window definition.
-     * @param {string} name The window definition name.
-     * @returns {WindowNode} A new window node.
-     */
-    over(name: string): WindowNode;
-    /**
-     * Return an updated window with the given partitions.
-     * @param {...ExprVarArgs} expr The partition by criteria.
-     * @returns {WindowNode} A new window node.
-     */
-    partitionby(...expr: ExprVarArgs[]): WindowNode;
-    /**
-     * Return an updated window with the given ordering.
-     * @param {...ExprVarArgs} expr The order by criteria.
-     * @returns {WindowNode} A new window node.
-     */
-    orderby(...expr: ExprVarArgs[]): WindowNode;
-    /**
-     * 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(extent: FrameExtent): WindowNode;
-    /**
-     * 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(extent: FrameExtent): WindowNode;
-}
-export class WindowFunctionNode extends FunctionNode {
-    /**
-     * Instantiate a window function call node.
-     * @param {WindowFunctionName} name The function name.
-     * @param {ExprNode[]} [args=[]] The function arguments.
-     */
-    constructor(name: WindowFunctionName, args?: ExprNode[]);
-}
-export class WindowDefNode extends SQLNode {
-    /**
-     * 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.
-     */
-    constructor(name?: string, partition?: ExprNode[], order?: ExprNode[], frame?: WindowFrameNode);
-    /**
-     * The base window definition name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The partition by criteria.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly partition: ExprNode[];
-    /**
-     * The order by criteria.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly order: ExprNode[];
-    /**
-     * The window frame definition.
-     * @type {WindowFrameNode}
-     * @readonly
-     */
-    readonly frame: WindowFrameNode;
-    /**
-     * 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.
-     */
-    over(name: string): WindowDefNode;
-    /**
-     * Return an updated window definition with the given partitions.
-     * @param {...ExprVarArgs} expr The partition by criteria.
-     * @returns {WindowDefNode} A new window definition node.
-     */
-    partitionby(...expr: ExprVarArgs[]): WindowDefNode;
-    /**
-     * Return an updated window definition with the given ordering.
-     * @param {...ExprVarArgs} expr The order by criteria.
-     * @returns {WindowDefNode} A new window definition node.
-     */
-    orderby(...expr: ExprVarArgs[]): WindowDefNode;
-    /**
-     * 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(extent: FrameExtent): WindowDefNode;
-    /**
-     * 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(extent: FrameExtent): WindowDefNode;
-}
-export class WindowFrameNode extends SQLNode {
-    /**
-     * 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.
-     */
-    constructor(extent: FrameExtent, range?: boolean, exclude?: ExprNode);
-    /**
-     * The frame extent as [preceding, following] row or interval offsets.
-     * @type {ParamNode | [any, any]}
-     * @readonly
-     */
-    readonly extent: ParamNode | [any, any];
-    /**
-     * The frame type: `true` for range, otherwise rows.
-     * @type {boolean}
-     * @readonly
-     */
-    readonly range: boolean;
-    /**
-     * The window exclusion criteria.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly exclude: ExprNode;
-}
-export type FrameExtent = [any, any] | ParamLike;
-import { SQLNode } from './node.js';
-import { ExprNode } from './node.js';
-import type { AggregateNode } from './aggregate.js';
-import type { ExprVarArgs } from '../types.js';
-import { FunctionNode } from './function.js';
-import type { WindowFunctionName } from '../types.js';
-import { ParamNode } from './param.js';
-import type { ParamLike } from '../types.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";