@uwdata/mosaic-sql 0.16.2 → 0.18.0

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

@@ -1,46 +0,0 @@
-export class BetweenOpNode extends AbstractBetweenOpNode {
-    /**
-     * Instantiate a between operator node.
-     * @param {ExprNode} expr The input expression.
-     * @param {[ExprNode, ExprNode]} extent
-     *  The range extent.
-     */
-    constructor(expr: ExprNode, extent: [ExprNode, ExprNode]);
-}
-export class NotBetweenOpNode extends AbstractBetweenOpNode {
-    /**
-     * Instantiate a not between operator node.
-     * @param {ExprNode} expr The input expression.
-     * @param {[ExprNode, ExprNode]} extent
-     *  The range extent.
-     */
-    constructor(expr: ExprNode, extent: [ExprNode, ExprNode]);
-}
-declare class AbstractBetweenOpNode extends ExprNode {
-    /**
-     * Instantiate an abstract between operator node.
-     * @param {string} type The node type.
-     * @param {ExprNode} expr The input expression.
-     * @param {[ExprNode, ExprNode]} extent The range extent.
-     */
-    constructor(type: string, expr: ExprNode, extent: [ExprNode, ExprNode]);
-    /**
-     * The input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * The range extent.
-     * @type {[ExprNode, ExprNode]}
-     * @readonly
-     */
-    readonly extent: [ExprNode, ExprNode];
-    /**
-     * Generate a SQL query string for this node.
-     * @returns {string}
-     */
-    toSQL(op: any): string;
-}
-import { ExprNode } from './node.js';
-export {};

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

@@ -1,28 +0,0 @@
-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: string, left: ExprNode, right: ExprNode);
-    /**
-     * The operator type.
-     * @type {string}
-     * @readonly
-     */
-    readonly op: string;
-    /**
-     * The left input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly left: ExprNode;
-    /**
-     * The right input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly right: ExprNode;
-}
-import { ExprNode } from './node.js';

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

@@ -1,67 +0,0 @@
-export class CaseNode extends ExprNode {
-    /**
-     * Instantiate a case node.
-     * @param {ExprNode} [expr] An optional base expression, that comes
-     *  immediately after the CASE keyword. If specified, this case statement
-     *  acts like a switch statement, with WHEN expressions as values to
-     *  match against the switch value rather than boolean conditions.
-     * @param {WhenNode[]} [when] An array of WHEN/THEN expression nodes.
-     * @param {ExprNode} [elseExpr] An ELSE expression.
-     */
-    constructor(expr?: ExprNode, when?: WhenNode[], elseExpr?: ExprNode);
-    /**
-     * The optional base expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * An array of WHEN/THEN expression nodes.
-     * @type {WhenNode[]}
-     * @readonly
-     */
-    readonly _when: WhenNode[];
-    /**
-     * An ELSE expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly _else: ExprNode;
-    /**
-     * Return a new case node with the given conditional added as
-     * the last WHEN / THEN pair.
-     * @param {ExprValue} cond The WHEN condition expression.
-     * @param {ExprValue} value The THEN value expression.
-     * @returns {CaseNode}
-     */
-    when(cond: ExprValue, value: ExprValue): CaseNode;
-    /**
-     * Return a new case node with the given ELSE expression.
-     * @param {ExprValue} expr The ELSE expression.
-     * @returns {CaseNode}
-     */
-    else(expr: ExprValue): CaseNode;
-}
-export class WhenNode extends SQLNode {
-    /**
-     * Instantiate a case node.
-     * @param {ExprNode} when The WHEN condition expression.
-     * @param {ExprNode} then The THEN value expression.
-     */
-    constructor(when: ExprNode, then: ExprNode);
-    /**
-     * The condition expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly when: ExprNode;
-    /**
-     * The value expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly then: ExprNode;
-}
-import { ExprNode } from './node.js';
-import type { ExprValue } from '../types.js';
-import { SQLNode } from './node.js';

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

@@ -1,21 +0,0 @@
-export class CastNode extends ExprNode {
-    /**
-     * Instantiate a cast node.
-     * @param {ExprNode} expr The expression to type cast.
-     * @param {string} type The type to cast to.
-     */
-    constructor(expr: ExprNode, type: string);
-    /**
-     * The expression to type cast.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * The type to cast to.
-     * @type {string}
-     * @readonly
-     */
-    readonly cast: string;
-}
-import { ExprNode } from './node.js';

package/dist/types/ast/column-param.d.ts

@@ -1,23 +0,0 @@
-/**
- * Check if a value is a dynamic column reference node.
- * @param {*} value The value to check.
- * @returns {value is ColumnParamNode}
- */
-export function isColumnParam(value: any): value is 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: ParamNode, table?: TableRefNode);
-    /**
-     * The column name as a parameter node.
-     * @type {ParamNode}
-     * @readonly
-     */
-    readonly param: ParamNode;
-}
-import { ColumnRefNode } from './column-ref.js';
-import type { ParamNode } from './param.js';
-import type { TableRefNode } from './table-ref.js';

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

@@ -1,40 +0,0 @@
-/**
- * Check if a value is a column reference node.
- * @param {*} value The value to check.
- * @returns {value is ColumnRefNode}
- */
-export function isColumnRef(value: any): value is ColumnRefNode;
-export class ColumnRefNode extends ExprNode {
-    /**
-     * Instantiate a column reference node.
-     * @param {TableRefNode} [table] The table reference.
-     */
-    constructor(type: any, table?: TableRefNode);
-    /**
-     * The table reference.
-     * @type {TableRefNode}
-     * @readonly
-     */
-    readonly table: TableRefNode;
-    /**
-     * Returns the column name.
-     * @returns {string}
-     */
-    get column(): string;
-}
-export class ColumnNameRefNode extends ColumnRefNode {
-    /**
-     * Instantiate a column reference node.
-     * @param {string} name The column name.
-     * @param {TableRefNode} [table] The table reference.
-     */
-    constructor(name: string, table?: TableRefNode);
-    /**
-     * The column name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-}
-import { ExprNode } from './node.js';
-import type { TableRefNode } from './table-ref.js';

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

@@ -1,14 +0,0 @@
-export class FragmentNode extends ExprNode {
-    /**
-     * Instantiate a fragment node with arbitrary content.
-     * @param {ExprNode[]} spans The consecutive parts making up the fragment.
-     */
-    constructor(spans: ExprNode[]);
-    /**
-     * The consecutive parts making up the fragment.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly spans: ExprNode[];
-}
-import { ExprNode } from './node.js';

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

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

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

@@ -1,21 +0,0 @@
-export class FunctionNode extends ExprNode {
-    /**
-     * Instantiate a function node.
-     * @param {string} name The function name.
-     * @param {ExprNode[]} [args=[]] The function arguments.
-     */
-    constructor(name: string, args?: ExprNode[]);
-    /**
-     * The function name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The function arguments.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly args: ExprNode[];
-}
-import { ExprNode } from './node.js';

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

@@ -1,21 +0,0 @@
-export class InOpNode extends ExprNode {
-    /**
-     * Instantiate an in operator node.
-     * @param {ExprNode} expr The input expression.
-     * @param {ExprNode[]} values The value set.
-     */
-    constructor(expr: ExprNode, values: ExprNode[]);
-    /**
-     * The input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * The value set.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly values: ExprNode[];
-}
-import { ExprNode } from './node.js';

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

@@ -1,21 +0,0 @@
-export class IntervalNode extends ExprNode {
-    /**
-     * Instantiate an interval node.
-     * @param {string} name The interval name.
-     * @param {number} [steps=1] The interval steps.
-     */
-    constructor(name: string, steps?: number);
-    /**
-     * The interval name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The interval steps.
-     * @type {number}
-     * @readonly
-     */
-    readonly steps: number;
-}
-import { ExprNode } from './node.js';

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

@@ -1,15 +0,0 @@
-export function literalToSQL(value: any): string;
-export class LiteralNode extends ExprNode {
-    /**
-     * Instantiate an literal node.
-     * @param {*} value The literal value.
-     */
-    constructor(value: any);
-    /**
-     * The literal value.
-     * @type {any}
-     * @readonly
-     */
-    readonly value: any;
-}
-import { ExprNode } from './node.js';

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

@@ -1,46 +0,0 @@
-/**
- * @template {ExprNode} T
- */
-export class LogicalOpNode<T extends ExprNode> extends ExprNode {
-    /**
-     * Instantiate a logical operator node.
-     * @param {string} op The logical operation.
-     * @param {T[]} clauses The input clause expressions.
-     */
-    constructor(op: string, clauses: T[]);
-    /**
-     * The logical operator.
-     * @type {string}
-     * @readonly
-     */
-    readonly op: string;
-    /**
-     * The input clause expressions.
-     * @type {T[]}
-     * @readonly
-     */
-    readonly clauses: T[];
-}
-/**
- * @template {ExprNode} T
- * @extends {LogicalOpNode<T>}
- */
-export class AndNode<T extends ExprNode> extends LogicalOpNode<T> {
-    /**
-     * Instantiate a logical AND operator node.
-     * @param {T[]} clauses The input clause expressions.
-     */
-    constructor(clauses: T[]);
-}
-/**
- * @template {ExprNode} T
- * @extends {LogicalOpNode<T>}
- */
-export class OrNode<T extends ExprNode> extends LogicalOpNode<T> {
-    /**
-     * Instantiate a logical OR operator node.
-     * @param {T[]} clauses The input clause expressions.
-     */
-    constructor(clauses: T[]);
-}
-import { ExprNode } from './node.js';

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

@@ -1,24 +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: any): value is SQLNode;
-export class SQLNode {
-    /**
-     * Instantiate a SQL AST node.
-     * @param {string} type The SQL AST node type.
-     */
-    constructor(type: string);
-    /**
-     * The SQL AST node type.
-     * @type {string}
-     * @readonly
-     */
-    readonly type: string;
-}
-/**
- * AST node corresponding to an individual expression.
- */
-export class ExprNode extends SQLNode {
-}

package/dist/types/ast/order-by.d.ts

@@ -1,29 +0,0 @@
-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: ExprNode, desc?: boolean | undefined, nullsFirst?: boolean | undefined);
-    /**
-     * The expression to order by.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly expr: ExprNode;
-    /**
-     * Flag indicating descending order.
-     * @type {boolean | undefined}
-     * @readonly
-     */
-    readonly desc: boolean | undefined;
-    /**
-     * Flag indicating if null values should be sorted first.
-     * @type {boolean | undefined}
-     * @readonly
-     */
-    readonly nullsFirst: boolean | undefined;
-}
-import { ExprNode } from './node.js';