@uwdata/mosaic-sql 0.16.2 → 0.18.0

package/dist/src/visit/rewrite.js

@@ -0,0 +1,39 @@
+import { isNode } from '../ast/node.js';
+import { recurse } from './recurse.js';
+/**
+ * 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 node The root AST node of the expression.
+ * @param map The rewrite map. When encountered, key nodes are replaced by value nodes.
+ */
+export function rewrite(node, map) {
+    if (map.has(node)) {
+        return map.get(node);
+    }
+    else if (isNode(node)) {
+        const props = recurse[node.type];
+        const n = props?.length ?? 0;
+        if (n > 0) {
+            node = node.clone();
+            for (let i = 0; i < n; ++i) {
+                const prop = props[i];
+                // @ts-expect-error lookup valid property
+                const child = node[prop];
+                if (Array.isArray(child)) {
+                    // @ts-expect-error rewrite known property
+                    const a = (node[prop] = child.slice());
+                    const m = child.length;
+                    for (let j = 0; j < m; ++j) {
+                        a[j] = rewrite(child[j], map);
+                    }
+                }
+                else if (child) {
+                    // @ts-expect-error rewrite known property
+                    node[prop] = rewrite(child, map);
+                }
+            }
+        }
+    }
+    return node;
+}
+//# sourceMappingURL=rewrite.js.map

package/dist/src/visit/rewrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.js","sourceRoot":"","sources":["../../../src/visit/rewrite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,IAAc,EAAE,GAA4B;IAClE,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClB,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;SAAM,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACV,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;YACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACtB,yCAAyC;gBACzC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;gBACzB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBACzB,0CAA0C;oBAC1C,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;oBACvC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;oBACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;wBAC3B,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;oBAChC,CAAC;gBACH,CAAC;qBAAM,IAAI,KAAK,EAAE,CAAC;oBACjB,0CAA0C;oBAC1C,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/{types → src}/visit/visitors.d.ts

@@ -1,34 +1,32 @@
+import { type AggregateNode } from '../ast/aggregate.js';
+import type { ColumnRefNode } from '../ast/column-ref.js';
+import type { SQLNode } from '../ast/node.js';
+import type { ParamLike } from '../types.js';
 /**
  * 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.
+ * @param root The root of the AST to search.
+ * @returns 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;
+export declare function isAggregateExpression(root: SQLNode): number;
 /**
  * Collect all aggregate function nodes.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {AggregateNode[]}
+ * @param root The root of the AST to search.
  */
-export function collectAggregates(root: SQLNode): AggregateNode[];
+export declare 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[]}
+ * @param root The root of the AST to search.
  */
-export function collectColumns(root: SQLNode): ColumnRefNode[];
+export declare function collectColumns(root: SQLNode): ColumnRefNode[];
 /**
  * Collect all unique dynamic parameter instances.
- * @param {SQLNode} root The root of the AST to search.
- * @returns {ParamLike[]}
+ * @param root The root of the AST to search.
  */
-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';
+export declare function collectParams(root: SQLNode): ParamLike[];
+//# sourceMappingURL=visitors.d.ts.map

package/dist/src/visit/visitors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitors.d.ts","sourceRoot":"","sources":["../../../src/visit/visitors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,qBAAqB,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAkB7C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,UA4BlD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,mBAQ9C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,mBAS3C;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,eAQ1C"}

package/dist/src/visit/visitors.js

@@ -0,0 +1,95 @@
+import { aggregateNames } from '../ast/aggregate.js';
+import { AGGREGATE, COLUMN_PARAM, COLUMN_REF, FRAGMENT, PARAM, VERBATIM, WINDOW } from '../constants.js';
+import { walk } from './walk.js';
+// regexp to match valid aggregate function names
+const aggrRegExp = new RegExp(`^(${aggregateNames.join('|')})$`);
+// regexp to tokenize sql text in order to find function calls
+// includes checks to avoid analyzing text within quoted strings
+// function call tokens will have a pattern like "name(".
+const funcRegExp = /(\\'|\\"|"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|\w+\()/g;
+function hasVerbatimAggregate(s) {
+    return s
+        .split(funcRegExp)
+        .some(tok => tok.endsWith('(') && aggrRegExp.test(tok.slice(0, -1)));
+}
+/**
+ * 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 root The root of the AST to search.
+ * @returns 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) {
+    let agg = 0;
+    walk(root, (node) => {
+        switch (node.type) {
+            case WINDOW:
+                return -1; // aggs can't include windows
+            case AGGREGATE:
+                agg |= 1;
+                return -1;
+            case FRAGMENT:
+            case VERBATIM: {
+                let s = `${node}`.toLowerCase();
+                // strip away scalar subquery content
+                const sub = s.indexOf('(select ');
+                if (sub >= 0)
+                    s = s.slice(0, sub);
+                // exit if expression includes windowing
+                if (s.includes(') over '))
+                    return -1;
+                if (hasVerbatimAggregate(s)) {
+                    agg |= 2;
+                    return -1;
+                }
+                return 1; // don't recurse
+            }
+        }
+    });
+    return agg;
+}
+/**
+ * Collect all aggregate function nodes.
+ * @param root The root of the AST to search.
+ */
+export function collectAggregates(root) {
+    const aggs = new Set();
+    walk(root, (node) => {
+        if (node.type === AGGREGATE) {
+            aggs.add(node);
+        }
+    });
+    return Array.from(aggs);
+}
+/**
+ * Collect all unique column references.
+ * Multiple references to the same column are de-duplicated, even if
+ * they are not object-equal node instances.
+ * @param root The root of the AST to search.
+ */
+export function collectColumns(root) {
+    const cols = {};
+    walk(root, (node) => {
+        if (node.type === COLUMN_REF || node.type === COLUMN_PARAM) {
+            // key on string-coerced node
+            cols[`${node}`] = node;
+        }
+    });
+    return Object.values(cols);
+}
+/**
+ * Collect all unique dynamic parameter instances.
+ * @param root The root of the AST to search.
+ */
+export function collectParams(root) {
+    const params = new Set;
+    walk(root, (node) => {
+        if (node.type === PARAM) {
+            params.add(node.param);
+        }
+    });
+    return Array.from(params);
+}
+//# sourceMappingURL=visitors.js.map

package/dist/src/visit/visitors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitors.js","sourceRoot":"","sources":["../../../src/visit/visitors.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,21 @@
+import type { SQLNode } from '../ast/node.js';
+/**
+ * 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;
+/**
+ * Perform a traversal of a SQL expression AST.
+ * @param node Root node for AST traversal.
+ * @param visit Visitor callback function.
+ */
+export declare function walk(node: unknown, visit: VisitorCallback): VisitorResult;
+//# sourceMappingURL=walk.d.ts.map

package/dist/src/visit/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../../../src/visit/walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAI9C;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,aAAa,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,eAAe,GAAG,aAAa,CAqBzE"}

package/dist/src/visit/walk.js

@@ -0,0 +1,32 @@
+import { isNode } from '../ast/node.js';
+import { recurse } from './recurse.js';
+/**
+ * Perform a traversal of a SQL expression AST.
+ * @param node Root node for AST traversal.
+ * @param visit Visitor callback function.
+ */
+export function walk(node, visit) {
+    if (!isNode(node))
+        return;
+    const result = visit(node);
+    if (result)
+        return result;
+    const props = recurse[node.type];
+    const n = props?.length ?? 0;
+    for (let i = 0; i < n; ++i) {
+        // @ts-expect-error lookup of valid property
+        const value = node[props[i]];
+        if (Array.isArray(value)) {
+            const m = value.length;
+            for (let j = 0; j < m; ++j) {
+                if (value[j] && Number(walk(value[j], visit)) < 0) {
+                    return result;
+                }
+            }
+        }
+        else if (value && Number(walk(value, visit)) < 0) {
+            return -1;
+        }
+    }
+}
+//# sourceMappingURL=walk.js.map

package/dist/src/visit/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.js","sourceRoot":"","sources":["../../../src/visit/walk.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAiBvC;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,IAAa,EAAE,KAAsB;IACxD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;QAAE,OAAO;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAE1B,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAC3B,4CAA4C;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC3B,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;oBAClD,OAAO,MAAM,CAAC;gBAChB,CAAC;YACH,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;YACnD,OAAO,CAAC,CAAC,CAAC;QACZ,CAAC;IACH,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-sql",
-  "version": "0.16.2",
+  "version": "0.18.0",
   "description": "SQL query construction and analysis.",
   "keywords": [
     "sql",
@@ -11,21 +11,23 @@
   "author": "Jeffrey Heer (https://idl.uw.edu)",
   "type": "module",
   "exports": {
-    "types": "./dist/types/index-types.d.ts",
-    "default": "./src/index.js"
+    "types": "./dist/src/index.d.ts",
+    "default": "./dist/src/index.js"
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "src"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/uwdata/mosaic.git"
   },
   "scripts": {
-    "prebuild": "rimraf dist && mkdir dist",
-    "build": "npm run types",
-    "types": "tsc",
+    "clean": "rimraf dist && mkdir dist",
     "lint": "eslint src test",
-    "test": "vitest run && npm run tsc",
-    "tsc": "tsc -p jsconfig.json",
-    "prepublishOnly": "npm run test && npm run lint && npm run build"
+    "test": "vitest run",
+    "prepublishOnly": "npm run test && npm run lint && tsc --build"
   },
-  "gitHead": "26d2719f4bcab471d2831145e1f03f39f3509869"
+  "gitHead": "dfb9ded0b0307754e3185ca34cc49a1384fe8455"
 }

package/src/ast/aggregate.ts

@@ -0,0 +1,198 @@
+import type { ExprVarArgs, OrderByExpr } from '../types.js';
+import type { WindowFrameNode } from './window-frame.js';
+import { AGGREGATE } from '../constants.js';
+import { asVerbatim } from '../util/ast.js';
+import { nodeList } from '../util/function.js';
+import { isString } from '../util/type-check.js';
+import { ExprNode } from './node.js';
+import { WindowNode } from './window.js';
+
+export class AggregateNode extends ExprNode {
+  /** The aggregate function name. */
+  readonly name: string;
+  /** The aggregate function arguments. */
+  readonly args: ExprNode[];
+  /** The distinct flag. */
+  readonly isDistinct: boolean;
+  /** Filter criteria. */
+  readonly filter: ExprNode | null;
+  /** Order by expression for order-sensitive aggregates. */
+  readonly order: ExprNode[];
+
+  /**
+   * Instantiate an aggregate function node.
+   * @param name The aggregate function name.
+   * @param args The aggregate function arguments.
+   * @param distinct The distinct flag.
+   * @param filter Filter expression.
+   * @param argOrder Order by expression.
+   */
+  constructor(
+    name: string,
+    args: ExprNode[],
+    distinct: boolean = false,
+    filter: ExprNode | null = null,
+    argOrder: OrderByExpr = []
+  ) {
+    super(AGGREGATE);
+    this.name = name;
+    this.args = args;
+    this.isDistinct = distinct;
+    this.filter = filter;
+    this.order = nodeList([argOrder]);
+  }
+
+  /**
+   * Return a new derived aggregate over distinct values.
+   * @param isDistinct The distinct flag.
+   * @returns A new aggregate node.
+   */
+  distinct(isDistinct: boolean = true) {
+    return new AggregateNode(this.name, this.args, isDistinct, this.filter, this.order);
+  }
+
+  /**
+   * Return a new derived aggregate function that filters values.
+   * @param The filter expression.
+   * @returns A new aggregate node.
+   */
+  where(filter: ExprNode | string) {
+    if (isString(filter)) filter = asVerbatim(filter);
+    return new AggregateNode(this.name, this.args, this.isDistinct, filter, this.order);
+  }
+
+  /**
+   * Return a new derived aggregate function that sorts values prior to aggregation.
+   * @param order The order by expression.
+   * @returns A new aggregate node.
+   */
+  argOrder(order: OrderByExpr) {
+    return new AggregateNode(this.name, this.args, this.isDistinct, this.filter, order);
+  }
+
+  /**
+   * Return a new window function over this aggregate.
+   * @returns A new window node.
+   */
+  window() {
+    return new WindowNode(this);
+  }
+
+  /**
+   * Return a new window function over this aggregate with the given partitions.
+   * @param expr The partition by criteria.
+   * @returns A new window node.
+   */
+  partitionby(...expr: ExprVarArgs[]) {
+    return this.window().partitionby(...expr);
+  }
+
+  /**
+   * Return a new window function over this aggregate with the given ordering.
+   * @param expr The order by criteria.
+   * @returns A new window node.
+   */
+  orderby(...expr: ExprVarArgs[]) {
+    return this.window().orderby(...expr);
+  }
+
+  /**
+   * Return a new window function over this aggregate with the given frame.
+   * @param framedef The window frame definition.
+   * @returns A new window node.
+   */
+  frame(framedef: WindowFrameNode) {
+    return this.window().frame(framedef);
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   */
+  toString() {
+    const { name, args, isDistinct, filter, order } = this;
+    const arg = [
+      isDistinct ? 'DISTINCT' : '',
+      args?.length ? args.join(', ')
+        : name.toLowerCase() === 'count' ?  '*'
+        : '',
+      order.length ? `ORDER BY ${order.join(', ')}` : ''
+    ].filter(x => x).join(' ');
+    const filt = filter ? ` FILTER (WHERE ${filter})` : '';
+    return `${name}(${arg})${filt}`;
+  }
+}
+
+/**
+ * Check if a function name corresponds to an aggregate function.
+ * @param name The function name to check
+ * @returns True if a known aggregate function, false otherwise.
+ */
+export function isAggregateFunction(name: string) {
+  return aggregateNames.includes(name.toLowerCase());
+}
+
+/**
+ * An array of known aggregate function names.
+ * From https://duckdb.org/docs/sql/functions/aggregates.html.
+ */
+export const aggregateNames = [
+  'any_value',
+  'approx_count_distinct',
+  'approx_quantile',
+  'arbitrary',
+  'arg_max',
+  'arg_max_null',
+  'arg_min',
+  'arg_min_null',
+  'array_agg',
+  'avg',
+  'bit_and',
+  'bit_or',
+  'bit_xor',
+  'bitstring_agg',
+  'bool_and',
+  'bool_or',
+  'corr',
+  'count',
+  'count_star',
+  'covar_pop',
+  'covar_samp',
+  'entropy',
+  'favg',
+  'first',
+  'fsum',
+  'geomean',
+  'kurtosis_pop',
+  'kurtosis',
+  'last',
+  'mad',
+  'max',
+  'max_by',
+  'median',
+  'min',
+  'min_by',
+  'mode',
+  'product',
+  'quantile',
+  'quantile_cont',
+  'quantile_disc',
+  'regr_avgx',
+  'regr_avgy',
+  'regr_count',
+  'regr_intercept',
+  'regr_r2',
+  'regr_sxx',
+  'regr_sxy',
+  'regr_syy',
+  'regr_slope',
+  'reservoir_quantile',
+  'skewness',
+  'stddev',
+  'stddev_pop',
+  'stddev_samp',
+  'string_agg',
+  'sum',
+  'variance',
+  'var_pop',
+  'var_samp'
+];

package/src/ast/{between-op.js → between-op.ts}

@@ -1,34 +1,31 @@
 import { BETWEEN_OPERATOR, NOT_BETWEEN_OPERATOR } from '../constants.js';
 import { ExprNode } from './node.js';
 
+export type Extent = [ExprNode, ExprNode] | null;
+
 class AbstractBetweenOpNode extends ExprNode {
+  /** The input expression. */
+  readonly expr: ExprNode;
+  /** The range extent. */
+  readonly extent?: Extent;
+
   /**
    * 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.
+   * @param type The node type.
+   * @param expr The input expression.
+   * @param extent The range extent.
    */
-  constructor(type, expr, extent) {
+  constructor(type: string, expr: ExprNode, extent?: Extent) {
     super(type);
-    /**
-     * The input expression.
-     * @type {ExprNode}
-     * @readonly
-     */
     this.expr = expr;
-    /**
-     * The range extent.
-     * @type {[ExprNode, ExprNode]}
-     * @readonly
-     */
     this.extent = extent;
   }
 
   /**
    * Generate a SQL query string for this node.
-   * @returns {string}
+   * @param op The operator to apply.
    */
-  toSQL(op) {
+  toSQL(op: string) {
     const { extent: r, expr } = this;
     return r ? `(${expr} ${op} ${r[0]} AND ${r[1]})` : '';
   }
@@ -37,17 +34,15 @@ class AbstractBetweenOpNode extends ExprNode {
 export class BetweenOpNode extends AbstractBetweenOpNode {
   /**
    * Instantiate a between operator node.
-   * @param {ExprNode} expr The input expression.
-   * @param {[ExprNode, ExprNode]} extent
-   *  The range extent.
+   * @param expr The input expression.
+   * @param extent The range extent.
    */
-  constructor(expr, extent) {
+  constructor(expr: ExprNode, extent?: Extent) {
     super(BETWEEN_OPERATOR, expr, extent);
   }
 
   /**
    * Generate a SQL query string for this node.
-   * @returns {string}
    */
   toString() {
     return super.toSQL('BETWEEN');
@@ -57,17 +52,15 @@ export class BetweenOpNode extends AbstractBetweenOpNode {
 export class NotBetweenOpNode extends AbstractBetweenOpNode {
   /**
    * Instantiate a not between operator node.
-   * @param {ExprNode} expr The input expression.
-   * @param {[ExprNode, ExprNode]} extent
-   *  The range extent.
+   * @param expr The input expression.
+   * @param extent The range extent.
    */
-  constructor(expr, extent) {
+  constructor(expr: ExprNode, extent?: Extent) {
     super(NOT_BETWEEN_OPERATOR, expr, extent);
   }
 
   /**
    * Generate a SQL query string for this node.
-   * @returns {string}
    */
   toString() {
     return super.toSQL('NOT BETWEEN');

package/src/ast/binary-op.ts

@@ -0,0 +1,31 @@
+import { BINARY_OPERATOR } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class BinaryOpNode extends ExprNode {
+  /** The operator type. */
+  readonly op: string;
+  /** The left input expression. */
+  readonly left: ExprNode;
+  /** The right input expression. */
+  readonly right: ExprNode;
+
+  /**
+   * Instantiate a binary operator node.
+   * @param op The operator type.
+   * @param left The left input expression.
+   * @param right The right input expression.
+   */
+  constructor(op: string, left: ExprNode, right: ExprNode) {
+    super(BINARY_OPERATOR);
+    this.op = op;
+    this.left = left;
+    this.right = right;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   */
+  toString() {
+    return `(${this.left} ${this.op} ${this.right})`;
+  }
+}