@uwdata/mosaic-sql 0.16.2 → 0.17.0

package/src/ast/window.js

@@ -1,19 +1,12 @@
 /**
+ * @import { ExprVarArgs, OrderByExpr, WindowFunctionName } from '../types.js'
  * @import { AggregateNode } from './aggregate.js'
- * @import { ExprVarArgs, WindowFunctionName } from '../types.js'
- * @import { ParamLike } from '../types.js'
+ * @import { WindowFrameNode } from './window-frame.js'
  */
-import { WINDOW, WINDOW_CLAUSE, WINDOW_DEF, WINDOW_FRAME } from '../constants.js';
+import { WINDOW, WINDOW_CLAUSE, WINDOW_DEF, WINDOW_FUNCTION } from '../constants.js';
 import { exprList } from '../util/function.js';
 import { quoteIdentifier } from '../util/string.js';
-import { isParamLike } from '../util/type-check.js';
-import { FunctionNode } from './function.js';
-import { ExprNode, isNode, SQLNode } from './node.js';
-import { ParamNode } from './param.js';
-
-/**
- * @typedef {[any, any] | ParamLike} FrameExtent
- */
+import { ExprNode, SQLNode } from './node.js';
 
 export class WindowClauseNode extends SQLNode {
   /**
@@ -90,21 +83,12 @@ export class WindowNode extends ExprNode {
   }
 
   /**
-   * 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) {
-    return new WindowNode(this.func, this.def.rows(extent));
-  }
-
-  /**
-   * Return an updated window with the given range frame.
-   * @param {FrameExtent} extent The range-based window frame extent.
+   * Return an updated window with the given frame definition.
+   * @param {WindowFrameNode} framedef The frame definition.
    * @returns {WindowNode} A new window node.
    */
-  range(extent) {
-    return new WindowNode(this.func, this.def.range(extent));
+  frame(framedef) {
+    return new WindowNode(this.func, this.def.frame(framedef));
   }
 
   /**
@@ -116,14 +100,55 @@ export class WindowNode extends ExprNode {
   }
 }
 
-export class WindowFunctionNode extends FunctionNode {
+export class WindowFunctionNode extends ExprNode {
   /**
    * Instantiate a window function call node.
-   * @param {WindowFunctionName} name The function name.
-   * @param {ExprNode[]} [args=[]] The function arguments.
+   * @param {WindowFunctionName} name The window function name.
+   * @param {ExprNode[]} [args=[]] The window function arguments.
+   * @param {boolean} [ignoreNulls=false] Flag to ignore null values.
+   * @param {OrderByExpr} [argOrder] Order expressions for window arguments.
+   *  Note that this argument ordering is distinct from the window ordering.
    */
-  constructor(name, args) {
-    super(name, args);
+  constructor(name, args = [], ignoreNulls = false, argOrder = []) {
+    super(WINDOW_FUNCTION);
+    /**
+     * The window function name.
+     * @type {string}
+     * @readonly
+     */
+    this.name = name;
+    /**
+     * The window function arguments.
+     * @type {ExprNode[]}
+     * @readonly
+     */
+    this.args = args;
+    /**
+     * Flag to ignore null values.
+     * @type {boolean}
+     * @readonly
+     */
+    this.ignoreNulls = ignoreNulls;
+    /**
+     * Order by expression for window arguments.
+     * @type {ExprNode[]}
+     * @readonly
+     */
+    this.order = exprList([argOrder]);
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { name, args, ignoreNulls, order } = this;
+    const arg = [
+      args.join(', '),
+      order.length ? `ORDER BY ${order.join(', ')}` : '',
+      ignoreNulls ? 'IGNORE NULLS' : ''
+    ].filter(x => x).join(' ');
+    return `${name}(${arg})`;
   }
 }
 
@@ -133,9 +158,9 @@ export class WindowDefNode extends SQLNode {
    * @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.
+   * @param {WindowFrameNode} [framedef] The window frame definition.
    */
-  constructor(name, partition, order, frame) {
+  constructor(name, partition, order, framedef) {
     super(WINDOW_DEF);
     /**
      * The base window definition name.
@@ -160,7 +185,7 @@ export class WindowDefNode extends SQLNode {
      * @type {WindowFrameNode}
      * @readonly
      */
-    this.frame = frame;
+    this.framedef = framedef;
   }
 
   /**
@@ -191,21 +216,12 @@ export class WindowDefNode extends SQLNode {
   }
 
   /**
-   * 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) {
-    return deriveDef(this, { frame: new WindowFrameNode(extent) });
-  }
-
-  /**
-   * Return an updated window definition with the given range frame.
-   * @param {FrameExtent} extent The range-based window frame extent.
+   * Return an updated window definition with the given frame definition.
+   * @param {WindowFrameNode} framedef The frame definition.
    * @returns {WindowDefNode} A new window definition node.
    */
-  range(extent) {
-    return deriveDef(this, { frame: new WindowFrameNode(extent, true) });
+  frame(framedef) {
+    return deriveDef(this, { framedef });
   }
 
   /**
@@ -213,62 +229,18 @@ export class WindowDefNode extends SQLNode {
    * @returns {string}
    */
   toString() {
-    const { name, partition, order, frame } = this;
+    const { name, partition, order, framedef } = this;
     const base = name && quoteIdentifier(name);
     const def = [
       base,
       partition?.length && `PARTITION BY ${partition.join(', ')}`,
       order?.length && `ORDER BY ${order.join(', ')}`,
-      frame
+      framedef
     ].filter(x => x);
     return base && def.length < 2 ? base : `(${def.join(' ')})`;
   }
 }
 
-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, range = false, exclude = undefined) {
-    super(WINDOW_FRAME);
-    /**
-     * The frame extent as [preceding, following] row or interval offsets.
-     * @type {ParamNode | [any, any]}
-     * @readonly
-     */
-    this.extent = isParamLike(extent) ? new ParamNode(extent) : extent;
-    /**
-     * The frame type: `true` for range, otherwise rows.
-     * @type {boolean}
-     * @readonly
-     */
-    this.range = range;
-    /**
-     * The window exclusion criteria.
-     * @type {ExprNode}
-     * @readonly
-     */
-    this.exclude = exclude;
-  }
-
-  /**
-   * Generate a SQL query string for this node.
-   * @returns {string}
-   */
-  toString() {
-    const { range, exclude, extent  } = this;
-    const type = range ? 'RANGE' : 'ROWS';
-    const [prev, next] = isNode(extent) ? extent.value : extent;
-    const a = frameValue(prev, 'PRECEDING');
-    const b = frameValue(next, 'FOLLOWING');
-    return `${type} BETWEEN ${a} AND ${b}${exclude ? ` ${exclude}` : ''}`;
-  }
-}
-
 /**
  * Derive a new window definition node from an existing one.
  * @param {WindowDefNode} def The existing window definition.
@@ -276,19 +248,13 @@ export class WindowFrameNode extends SQLNode {
  * @param {string} [options.name] The base window definition name.
  * @param {ExprNode[]} [options.partition] The partition by criteria.
  * @param {ExprNode[]} [options.order] The order by criteria.
- * @param {WindowFrameNode} [options.frame] The window frame definition.
+ * @param {WindowFrameNode} [options.framedef] The window frame definition.
  */
 function deriveDef(def, options) {
   return new WindowDefNode(
     options.name ?? def.name,
     options.partition ?? def.partition,
     options.order ?? def.order,
-    options.frame ?? def.frame
+    options.framedef ?? def.framedef
   );
 }
-
-function frameValue(value, order) {
-  return value === 0 ? 'CURRENT ROW'
-    : Number.isFinite(value) ? `${Math.abs(value)} ${order}`
-    : `UNBOUNDED ${order}`;
-}

package/src/constants.js

@@ -8,6 +8,7 @@ export const ORDER_BY = 'ORDER_BY';
 export const CAST = 'CAST';
 export const CASE = 'CASE';
 export const WHEN = 'WHEN';
+export const COLLATE = 'COLLATE';
 
 export const UNARY_OPERATOR = 'UNARY';
 export const UNARY_POSTFIX_OPERATOR = 'UNARY_POSTFIX';
@@ -20,8 +21,10 @@ export const IN_OPERATOR = 'IN';
 export const FUNCTION = 'FUNCTION';
 export const AGGREGATE = 'AGGREGATE';
 export const WINDOW = 'WINDOW';
+export const WINDOW_FUNCTION = 'WINDOW_FUNCTION';
 export const WINDOW_DEF = 'WINDOW_DEF';
 export const WINDOW_FRAME = 'WINDOW_FRAME';
+export const WINDOW_EXTENT_EXPR = 'WINDOW_EXTENT_EXPR';
 
 export const EXPRESSION = 'EXPRESSION';
 export const FRAGMENT = 'FRAGMENT';
@@ -29,16 +32,12 @@ export const VERBATIM = 'VERBATIM';
 export const PARAM = 'PARAM';
 
 export const WITH_CLAUSE = 'WITH_CLAUSE';
+export const WINDOW_CLAUSE = 'WINDOW_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';
+export const SCALAR_SUBQUERY = 'SCALAR_SUBQUERY';

package/src/functions/collate.js

@@ -0,0 +1,16 @@
+/**
+ * @import { ExprValue } from '../types.js'
+ */
+import { CollateNode } from '../ast/collate.js';
+import { asNode } from '../util/ast.js';
+
+/**
+ * Indicate ascending sort order for an expression.
+ * @param {ExprValue} expr The expression to collate.
+ * @param {string} collation The collation type, such as
+ *  'NOCASE', 'NOACCENT', 'NFC', or locale-specific collations.
+ * @returns {CollateNode}
+ */
+export function collate(expr, collation) {
+  return new CollateNode(asNode(expr), collation);
+}

package/src/functions/datetime.js

@@ -2,19 +2,9 @@
  * @import { FunctionNode } from '../ast/function.js'
  * @import { ExprValue } from '../types.js'
  */
-import { IntervalNode } from '../ast/interval.js';
 import { asNode } from '../util/ast.js';
 import { fn } from '../util/function.js';
-
-/**
- * Create a new interval.
- * @param {string} unit The interval unit, such as day or year.
- * @param {number} steps The number interval unit steps.
- * @returns {IntervalNode}
- */
-export function interval(unit, steps) {
-  return new IntervalNode(unit, steps);
-}
+import { interval } from './interval.js';
 
 /**
  * Given a date/time value, return the milliseconds since the UNIX epoch.

package/src/functions/interval.js

@@ -0,0 +1,83 @@
+import { IntervalNode } from '../ast/interval.js';
+
+/**
+ * Create a new interval.
+ * @param {string} unit The interval unit, such as day or year.
+ * @param {number} steps The number of interval unit steps.
+ * @returns {IntervalNode}
+ */
+export function interval(unit, steps) {
+  return new IntervalNode(unit, steps);
+}
+
+/**
+ * Create a new years interval.
+ * @param {number} steps The number of years.
+ * @returns {IntervalNode}
+ */
+export function years(steps) {
+  return interval('YEARS', steps);
+}
+
+/**
+ * Create a new months interval.
+ * @param {number} steps The number of months.
+ * @returns {IntervalNode}
+ */
+export function months(steps) {
+  return interval('MONTHS', steps);
+}
+
+/**
+ * Create a new days interval.
+ * @param {number} steps The number of days.
+ * @returns {IntervalNode}
+ */
+export function days(steps) {
+  return interval('DAYS', steps);
+}
+
+/**
+ * Create a new hours interval.
+ * @param {number} steps The number of hours.
+ * @returns {IntervalNode}
+ */
+export function hours(steps) {
+  return interval('HOURS', steps);
+}
+
+/**
+ * Create a new minutes interval.
+ * @param {number} steps The number of minutes.
+ * @returns {IntervalNode}
+ */
+export function minutes(steps) {
+  return interval('MINUTES', steps);
+}
+
+/**
+ * Create a new seconds interval.
+ * @param {number} steps The number of seconds.
+ * @returns {IntervalNode}
+ */
+export function seconds(steps) {
+  return interval('SECONDS', steps);
+}
+
+/**
+ * Create a new milliseconds interval.
+ * @param {number} steps The number of milliseconds.
+ * @returns {IntervalNode}
+ */
+export function milliseconds(steps) {
+  return interval('MILLISECONDS', steps);
+}
+
+/**
+ * Create a new microseconds interval.
+ * @param {number} steps The number of microseconds.
+ * @returns {IntervalNode}
+ */
+export function microseconds(steps) {
+  return interval('MICROSECONDS', steps);
+}

package/src/functions/literal.js

@@ -15,8 +15,9 @@ export function literal(value) {
 /**
  * Return a SQL AST node for verbatim string content.
  * @param {string} value The verbatim value.
+ * @param {string} [hint] A type hint for analyzing verbatim content.
  * @returns {VerbatimNode}
  */
-export function verbatim(value) {
-  return new VerbatimNode(value);
+export function verbatim(value, hint) {
+  return new VerbatimNode(value, hint);
 }

package/src/functions/window-frame.js

@@ -0,0 +1,61 @@
+/**
+ * @import { FrameExclude } from '../ast/window-frame.js'
+ * @import { FrameExtent, FrameValue } from '../types.js'
+ */
+import { CURRENT_ROW, FOLLOWING, GROUPS, PRECEDING, RANGE, ROWS, WindowFrameExprNode, WindowFrameNode } from '../ast/window-frame.js';
+
+/**
+ * Return an updated window definition with the given rows frame.
+ * @param {FrameExtent} extent The row-based window frame extent.
+ * @param {FrameExclude} [exclude] The window frame exclusion criteria.
+ * @returns {WindowFrameNode} A window frame node.
+ */
+export function frameRows(extent, exclude) {
+  return new WindowFrameNode(ROWS, extent, exclude);
+}
+
+/**
+ * Return an updated window definition with the given range frame.
+ * @param {FrameExtent} extent The range-based window frame extent.
+ * @param {FrameExclude} [exclude] The window frame exclusion criteria.
+ * @returns {WindowFrameNode} A window frame node.
+ */
+export function frameRange(extent, exclude) {
+  return new WindowFrameNode(RANGE, extent, exclude);
+}
+
+/**
+ * Return an updated window definition with the given groups frame.
+ * @param {FrameExtent} extent The group-based window frame extent.
+ * @param {FrameExclude} [exclude] The window frame exclusion criteria.
+ * @returns {WindowFrameNode} A window frame node.
+ */
+export function frameGroups(extent, exclude) {
+  return new WindowFrameNode(GROUPS, extent, exclude);
+}
+
+/**
+ * A `PRECEDING` frame value expression.
+ * @param {FrameValue} value The frame value.
+ * @returns {WindowFrameExprNode} A preceding value.
+ */
+export function preceding(value) {
+  return new WindowFrameExprNode(PRECEDING, value);
+}
+
+/**
+ * A `FOLLOWING` frame value expression.
+ * @param {FrameValue} value  The frame value.
+ * @returns {WindowFrameExprNode} A following value.
+ */
+export function following(value) {
+  return new WindowFrameExprNode(FOLLOWING, value);
+}
+
+/**
+ * A `CURRENT ROW` frame value expression.
+ * @returns {WindowFrameExprNode} A current row value.
+ */
+export function currentRow() {
+  return new WindowFrameExprNode(CURRENT_ROW);
+}

package/src/index.js

@@ -1,8 +1,9 @@
-export { AggregateNode } from './ast/aggregate.js';
+export { AggregateNode, aggregateNames, isAggregateFunction } from './ast/aggregate.js';
 export { BetweenOpNode, NotBetweenOpNode } from './ast/between-op.js'
 export { BinaryOpNode } from './ast/binary-op.js';
 export { CaseNode, WhenNode } from './ast/case.js';
 export { CastNode } from './ast/cast.js';
+export { CollateNode } from './ast/collate.js';
 export { ColumnParamNode, isColumnParam } from './ast/column-param.js';
 export { ColumnRefNode, ColumnNameRefNode, isColumnRef } from './ast/column-ref.js';
 export { FragmentNode } from './ast/fragment.js';
@@ -17,20 +18,24 @@ export { OrderByNode } from './ast/order-by.js';
 export { ParamNode } from './ast/param.js';
 export { DescribeQuery, Query, SelectQuery, SetOperation, isDescribeQuery, isQuery, isSelectQuery } from './ast/query.js';
 export { SampleClauseNode } from './ast/sample.js';
+export { ScalarSubqueryNode } from './ast/subquery.js';
 export { SelectClauseNode } from './ast/select.js';
 export { TableRefNode, isTableRef } from './ast/table-ref.js';
 export { UnaryOpNode, UnaryPosftixOpNode } from './ast/unary-op.js';
 export { VerbatimNode } from './ast/verbatim.js';
-export { WindowClauseNode, WindowDefNode, WindowFrameNode, WindowFunctionNode, WindowNode } from './ast/window.js';
+export { WindowClauseNode, WindowDefNode, WindowFunctionNode, WindowNode } from './ast/window.js';
+export { WindowFrameNode, WindowFrameExprNode } from './ast/window-frame.js';
 export { WithClauseNode } from './ast/with.js';
 
 export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, geomean, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from './functions/aggregate.js';
 export { cond } from './functions/case.js';
 export { cast, float32, float64, int32 } from './functions/cast.js';
+export { collate } from './functions/collate.js';
 export { column } from './functions/column.js';
 export { cte } from './functions/cte.js';
-export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms, interval } from './functions/datetime.js';
-export { literal } from './functions/literal.js';
+export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms } from './functions/datetime.js';
+export { days, hours, interval, microseconds, minutes, milliseconds, months, seconds, years } from './functions/interval.js';
+export { literal, verbatim } from './functions/literal.js';
 export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from './functions/numeric.js';
 export { and, or, not, isNull, isNotNull, bitNot, bitAnd, bitOr, bitLeft, bitRight, add, sub, mul, div, idiv, mod, pow, eq, neq, lt, gt, lte, gte, isDistinct, isNotDistinct, isBetween, isNotBetween, isIn } from './functions/operators.js';
 export { asc, desc } from './functions/order-by.js';
@@ -39,7 +44,9 @@ export { sql } from './functions/sql-template-tag.js';
 export { regexp_matches, contains, prefix, suffix, lower, upper, length } from './functions/string.js';
 export { coalesce } from './functions/util.js';
 export { cume_dist, dense_rank, first_value, lag, last_value, lead, nth_value, ntile, percent_rank, rank, row_number } from './functions/window.js';
+export { currentRow, following, frameGroups, frameRange, frameRows, preceding } from './functions/window-frame.js';
 
+export { deepClone } from './visit/clone.js';
 export { rewrite } from './visit/rewrite.js';
 export { collectAggregates, collectColumns, collectParams, isAggregateExpression } from './visit/visitors.js';
 export { walk } from './visit/walk.js';
@@ -54,6 +61,7 @@ export { binDate } from './transforms/bin-date.js';
 export { binHistogram } from './transforms/bin-histogram.js';
 export { binLinear1d } from './transforms/bin-linear-1d.js';
 export { binLinear2d } from './transforms/bin-linear-2d.js';
+export { filterQuery } from './transforms/filter-query.js';
 export { lineDensity } from './transforms/line-density.js';
 export { m4 } from './transforms/m4.js';
 export { scaleTransform } from './transforms/scales.js';

package/src/load/load.js

@@ -25,7 +25,7 @@ export function loadParquet(tableName, fileName, options) {
 /**
  * Load geometry data within a spatial file format.
  * This method requires that the DuckDB spatial extension is loaded.
- * Supports GeoJSON, TopoJSON, and other comomn spatial formats.
+ * Supports GeoJSON, TopoJSON, and other common spatial formats.
  * For TopoJSON, wet the layer option to indicate the feature to extract.
  */
 export function loadSpatial(tableName, fileName, options = {}) {

package/src/transforms/bin-date.js

@@ -2,7 +2,8 @@
  * @import { ExprNode } from '../ast/node.js'
  * @import { ExprValue, TimeUnit } from '../types.js'
  */
-import { dateBin, interval } from '../functions/datetime.js';
+import { dateBin } from '../functions/datetime.js';
+import { interval } from '../functions/interval.js';
 import { add } from '../functions/operators.js';
 import { timeInterval } from './util/time-interval.js';
 

package/src/transforms/filter-query.js

@@ -0,0 +1,44 @@
+/**
+ * @import { Query } from '../ast/query.js'
+ * @import { TableRefNode } from '../ast/table-ref.js'
+ * @import { FilterExpr } from '../types.js'
+ */
+import { isSelectQuery } from '../ast/query.js';
+import { isTableRef } from '../ast/table-ref.js';
+import { deepClone } from '../visit/clone.js';
+import { walk } from '../visit/walk.js';
+
+/**
+ * Returns a generator function that clones the given query and adds
+ * a WHERE clause for the specified table reference.
+ * @param {Query} query The query to clone and extend.
+ * @param {TableRefNode} tableRef The table to filter.
+ * @returns {(filter: FilterExpr) => Query} The generator function.
+ */
+export function filterQuery(query, tableRef) {
+  return (filter) => {
+    const clone = deepClone(query);
+    walk(clone, (node) => {
+      if (
+        isSelectQuery(node) &&
+        node._from.length === 1 &&
+        isTableRef(node._from[0].expr) &&
+        arrayEquals(node._from[0].expr.table, tableRef.table)
+      ) {
+        node.where(filter);
+      }
+    });
+    return clone;
+  };
+}
+
+function arrayEquals(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+
+  for (var i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}

package/src/types.ts

@@ -110,3 +110,12 @@ export type TimeUnit =
   | 'second'
   | 'millisecond'
   | 'microsecond';
+
+export type FrameValue =  ExprNode | number | null;
+
+export type FrameExtent = [FrameValue, FrameValue] | ParamLike;
+
+export type FrameScope =
+  | 'PRECEDING'
+  | 'FOLLOWING'
+  | 'CURRENT ROW';

package/src/visit/clone.js

@@ -0,0 +1,53 @@
+import { isNode } from '../ast/node.js';
+import { recurse } from './recurse.js';
+
+/**
+ * Create a deep clone of the given SQL AST node and all children nodes.
+ * @template T
+ * @param {T} node The node to deeply clone.
+ * @returns {T} The cloned node.
+ */
+export function deepClone(node) {
+  const clone = shallowClone(node);
+
+  if (isNode(node)) {
+    const props = recurse[node.type];
+    const n = props?.length ?? 0;
+    for (let i = 0; i < n; ++i) {
+      const key = props[i];
+      const value = node[key];
+      clone[key] = Array.isArray(value)
+        ? value.map(v => deepClone(v))
+        : deepClone(value);
+    }
+  }
+
+  return clone;
+}
+
+/**
+ * Create a shallow clone of the given SQL AST node.
+ * @template T
+ * @param {T} node The node to clone.
+ * @returns {T} The cloned node.
+ */
+function shallowClone(node) {
+  /** @type {T} */
+  let clone;
+
+  if (!node || typeof node !== 'object') {
+    return node;
+  } else if (isNode(node)) {
+    clone = node.clone();
+  } else if (node instanceof Date) {
+    // @ts-expect-error
+    return new Date(+node);
+  } else if (Array.isArray(node)) {
+    // @ts-expect-error
+    return node.slice();
+  } else {
+    return { ...node };
+  }
+
+  return clone;
+}