@uwdata/mosaic-sql 0.16.2 → 0.17.0

package/src/visit/recurse.js

@@ -4,6 +4,7 @@ import {
   BINARY_OPERATOR,
   CASE,
   CAST,
+  COLLATE,
   COLUMN_PARAM,
   COLUMN_REF,
   DESCRIBE_QUERY,
@@ -16,23 +17,29 @@ import {
   NOT_BETWEEN_OPERATOR,
   ORDER_BY,
   PARAM,
+  SCALAR_SUBQUERY,
   SELECT_CLAUSE,
   SELECT_QUERY,
   SET_OPERATION,
   UNARY_OPERATOR,
+  UNARY_POSTFIX_OPERATOR,
   WHEN,
   WINDOW,
   WINDOW_CLAUSE,
   WINDOW_DEF,
-  WINDOW_FRAME
+  WINDOW_EXTENT_EXPR,
+  WINDOW_FRAME,
+  WINDOW_FUNCTION,
+  WITH_CLAUSE
 } from '../constants.js';
 
 export const recurse = {
-  [AGGREGATE]: ['args', 'filter'],
+  [AGGREGATE]: ['args', 'order', 'filter'],
   [BETWEEN_OPERATOR]: ['expr', 'extent'],
   [BINARY_OPERATOR]: ['left', 'right'],
   [CASE]: ['expr', '_when', '_else'],
   [CAST]: ['expr'],
+  [COLLATE]: ['expr'],
   [COLUMN_PARAM]: ['param', 'table'],
   [COLUMN_REF]: ['table'],
   [DESCRIBE_QUERY]: ['query'],
@@ -45,13 +52,18 @@ export const recurse = {
   [NOT_BETWEEN_OPERATOR]: ['expr', 'extent'],
   [ORDER_BY]: ['expr'],
   [PARAM]: ['value'],
+  [SCALAR_SUBQUERY]: ['subquery'],
   [SELECT_CLAUSE]: ['expr'],
   [SELECT_QUERY]: ['_with', '_select', '_from', '_where', '_sample', '_groupby', '_having', '_window', '_qualify', '_orderby'],
-  [SET_OPERATION]: ['subqueries', '_orderby'],
+  [SET_OPERATION]: ['queries', '_orderby'],
   [UNARY_OPERATOR]: ['expr'],
+  [UNARY_POSTFIX_OPERATOR]: ['expr'],
   [WHEN]: ['when', 'then'],
   [WINDOW]: ['func', 'def'],
   [WINDOW_CLAUSE]: ['def'],
-  [WINDOW_DEF]: ['partition', 'order', 'frame'],
-  [WINDOW_FRAME]: ['extent']
+  [WINDOW_DEF]: ['partition', 'order', 'framedef'],
+  [WINDOW_EXTENT_EXPR]: ['expr'],
+  [WINDOW_FRAME]: ['extent'],
+  [WINDOW_FUNCTION]: ['args'],
+  [WITH_CLAUSE]: ['query']
 };

package/src/visit/rewrite.js

@@ -17,14 +17,15 @@ export function rewrite(node, map) {
     const props = recurse[node.type];
     const n = props?.length ?? 0;
     if (n > 0) {
-      node = cloneNode(node);
+      node = node.clone();
       for (let i = 0; i < n; ++i) {
         const prop = props[i];
         const child = node[prop];
         if (Array.isArray(child)) {
+          const a = (node[prop] = child.slice());
           const m = child.length;
           for (let j = 0; j < m; ++j) {
-            child[j] = rewrite(child[j], map);
+            a[j] = rewrite(child[j], map);
           }
         } else if (child) {
           node[prop] = rewrite(child, map);
@@ -34,12 +35,3 @@ export function rewrite(node, map) {
   }
   return node;
 }
-
-// TODO: consider typed node.clone() methods
-function cloneNode(node) {
-  const clone = new node.constructor();
-  for (const key in node) {
-    clone[key] = node[key];
-  }
-  return clone;
-}

package/src/visit/walk.js

@@ -1,7 +1,6 @@
 /**
  * @import { SQLNode } from '../ast/node.js'
  * @import { VisitorCallback, VisitorResult } from '../types.js'
-
  */
 import { isNode } from '../ast/node.js';
 import { recurse } from './recurse.js';

package/tsconfig.json

@@ -1,12 +1,8 @@
 {
-  "include": ["src/index-types.ts"],
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"],
   "compilerOptions": {
-    "allowJs": true,
-    "declaration": true,
     "emitDeclarationOnly": true,
-    "outDir": "dist/types",
-    "module": "node16",
-    "skipLibCheck": true,
-    "types": []
+    "outDir": "dist"
   }
 }

package/LICENSE

@@ -1,47 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2023, UW Interactive Data Lab
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
----
-
-Portions of this software are derived from Observable Plot, which is released
-under the ISC license.
-
-Copyright 2020-2023 Observable, Inc.
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-THIS SOFTWARE.

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

@@ -1,71 +0,0 @@
-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: string, args: ExprNode[], distinct?: boolean, filter?: ExprNode);
-    /**
-     * The aggregate function name.
-     * @type {string}
-     * @readonly
-     */
-    readonly name: string;
-    /**
-     * The aggregate function arguments.
-     * @type {ExprNode[]}
-     * @readonly
-     */
-    readonly args: ExprNode[];
-    /**
-     * The distinct flag.
-     * @type {boolean}
-     * @readonly
-     */
-    readonly isDistinct: boolean;
-    /**
-     * Filter criteria.
-     * @type {ExprNode}
-     * @readonly
-     */
-    readonly filter: ExprNode;
-    /**
-     * Return a new derived aggregate over distinct values.
-     * @param {boolean} [isDistinct=true] The distinct flag.
-     * @returns {AggregateNode} A new aggregate node.
-     */
-    distinct(isDistinct?: boolean): AggregateNode;
-    /**
-     * Return a new derived aggregate function that filters values.
-     * @param {ExprNode | string} filter The filter expression.
-     * @returns {AggregateNode} A new aggregate node.
-     */
-    where(filter: ExprNode | string): AggregateNode;
-    /**
-     * Return a new window function over this aggregate.
-     * @returns {WindowNode} A new window node.
-     */
-    window(): WindowNode;
-    /**
-     * 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: ExprVarArgs[]): WindowNode;
-    /**
-     * 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: ExprVarArgs[]): WindowNode;
-}
-/**
- * An array of known aggregate function names.
- * From https://duckdb.org/docs/sql/functions/aggregates.html.
- */
-export const aggregateNames: string[];
-import { ExprNode } from './node.js';
-import { WindowNode } from './window.js';
-import type { ExprVarArgs } from '../types.js';

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 {
-}