@uwdata/mosaic-sql 0.10.0 → 0.12.0

package/dist/types/functions/spatial.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Function that converts geometry data to GeoJSON format.
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function geojson(expr: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns a spatial x position (using ST_X).
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function x(expr: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns a spatial y position (using ST_Y).
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function y(expr: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns the centroid point for geometry data.
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function centroid(expr: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns the centroid x-coordinate for geometry data.
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function centroidX(expr: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns yhe centroid y-coordinate for geometry data.
+ * @param {import('../types.js').ExprValue} expr The input expression.
+ * @returns {FunctionNode}
+ */
+export function centroidY(expr: import("../types.js").ExprValue): FunctionNode;
+import { FunctionNode } from '../ast/function.js';

package/dist/types/functions/sql-template-tag.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @typedef {import('../ast/node.js').ExprNode
+ *  | import('../types.js').ParamLike
+ *  | string | number | boolean | Date
+ * } TemplateValue
+ */
+/**
+ * Template tag function for SQL fragments. Interpolated values
+ * may be strings, other SQL expression objects (such as column
+ * references), primitive values, or dynamic parameters.
+ * @param {TemplateStringsArray} strings Template string constants.
+ * @param {...TemplateValue} exprs Template expression values.
+ */
+export function sql(strings: TemplateStringsArray, ...exprs: TemplateValue[]): FragmentNode;
+export type TemplateValue = import("../ast/node.js").ExprNode | import("../types.js").ParamLike | string | number | boolean | Date;
+import { FragmentNode } from '../ast/fragment.js';

package/dist/types/functions/string.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Function that returns true if a string contains a regexp pattern,
+ * false otherwise.
+ * @param {import('../types.js').ExprValue} string The string match against.
+ * @param {import('../types.js').StringValue} pattern The regular expression pattern to match.
+ * @param {import('../types.js').StringValue} [options] Regular expression options:
+ *  'c': case-sensitive matching
+ *  'i': case-insensitive matching
+ *  'l': match literals instead of regular expression tokens
+ *  'm', 'n', 'p': newline sensitive matching
+ *  'g': global replace, only available for regexp_replace
+ *  's': non-newline sensitive matching
+ * @returns {FunctionNode}
+ */
+export function regexp_matches(string: import("../types.js").ExprValue, pattern: import("../types.js").StringValue, options?: import("../types.js").StringValue): FunctionNode;
+/**
+ * Function that returns true if search_string is found within string.
+ * @param {import('../types.js').ExprValue} string The string to match against.
+ * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @returns {FunctionNode}
+ */
+export function contains(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+/**
+ * Function that returns true if string begins with search_string.
+ * @param {import('../types.js').ExprValue} string The string to match against.
+ * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @returns {FunctionNode}
+ */
+export function prefix(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+/**
+ * Function that returns true if string ends with search_string.
+ * @param {import('../types.js').ExprValue} string The string to match against.
+ * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @returns {FunctionNode}
+ */
+export function suffix(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+/**
+ * Function that converts string to lower case.
+ * @param {import('../types.js').ExprValue} string The string to convert.
+ * @returns {FunctionNode}
+ */
+export function lower(string: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that converts string to upper case.
+ * @param {import('../types.js').ExprValue} string The string to convert.
+ * @returns {FunctionNode}
+ */
+export function upper(string: import("../types.js").ExprValue): FunctionNode;
+/**
+ * Function that returns the number of characters in string.
+ * @param {import('../types.js').ExprValue} value The string to measure.
+ * @returns {FunctionNode}
+ */
+export function length(value: import("../types.js").ExprValue): FunctionNode;
+import { FunctionNode } from '../ast/function.js';

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

@@ -0,0 +1,9 @@
+/**
+ * Returns a named table or view reference.
+ * @param {...(string | string[])} ids Table and namespace identifiers.
+ *  For example 'name' or ['schema', 'name'].
+ * @returns {TableRefNode | undefined} A table reference, or undefined
+ *  if the input identifier list is empty.
+ */
+export function tableRef(...ids: (string | string[])[]): TableRefNode | undefined;
+import { TableRefNode } from '../ast/table-ref.js';

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

@@ -0,0 +1,87 @@
+/**
+ * Create a window function that returns the number of the current row
+ * within the partition, counting from 1.
+ * @returns {WindowNode}
+ */
+export function row_number(): WindowNode;
+/**
+ * Create a window function that returns the rank of the current row with gaps.
+ * This is the same as the row_number of its first peer.
+ * @returns {WindowNode}
+ */
+export function rank(): WindowNode;
+/**
+ * Create a window function that returns the rank of the current row without
+ * gaps. The function counts peer groups.
+ * @returns {WindowNode}
+ */
+export function dense_rank(): WindowNode;
+/**
+ * Create a window function that returns the relative rank of the current row.
+ * Computed as (rank() - 1) / (total partition rows - 1).
+ * @returns {WindowNode}
+ */
+export function percent_rank(): WindowNode;
+/**
+ * Create a window function that returns the cumulative distribution. Computed
+ * as (number of preceding or peer partition rows) / total partition rows.
+ * @returns {WindowNode}
+ */
+export function cume_dist(): WindowNode;
+/**
+ * Create a window function that returns an integer ranging from 1 to the
+ * argument value, dividing the partition as equally as possible.
+ * @param {import('../types.js').NumberValue} num_buckets The number of
+ *  quantile buckets.
+ * @returns {WindowNode}
+ */
+export function ntile(num_buckets: import("../types.js").NumberValue): WindowNode;
+/**
+ * Create a window function that returns the expression evaluated at the row
+ * that is offset rows before the current row within the partition.
+ * If there is no such row, instead return default (which must be of the same
+ * type as the expression). Both offset and default are evaluated with respect
+ * to the current row. If omitted, offset defaults to 1 and default to null.
+ * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @param {import('../types.js').NumberValue} [offset] The row offset
+ *  (default `1`).
+ * @param {*} [defaultValue] The default value (default `null`).
+ * @returns {WindowNode}
+ */
+export function lag(expr: import("../types.js").ExprValue, offset?: import("../types.js").NumberValue, defaultValue?: any): WindowNode;
+/**
+ * Create a window function that returns the expression evaluated at the row
+ * that is offset rows after the current row within the partition.
+ * If there is no such row, instead return default (which must be of the same
+ * type as the expression). Both offset and default are evaluated with respect
+ * to the current row. If omitted, offset defaults to 1 and default to null.
+ * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @param {import('../types.js').NumberValue} [offset] The row offset
+ *  (default `1`).
+ * @param {*} [defaultValue] The default value (default `null`).
+ * @returns {WindowNode}
+ */
+export function lead(expr: import("../types.js").ExprValue, offset?: import("../types.js").NumberValue, defaultValue?: any): WindowNode;
+/**
+ * Create a window function that returns the expression evaluated at the row
+ * that is the first row of the window frame.
+ * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @returns {WindowNode}
+ */
+export function first_value(expr: import("../types.js").ExprValue): WindowNode;
+/**
+ * Create a window function that returns the expression evaluated at the row
+ * that is the last row of the window frame.
+ * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @returns {WindowNode}
+ */
+export function last_value(expr: import("../types.js").ExprValue): WindowNode;
+/**
+ * Create a window function that returns the expression evaluated at the
+ * nth row of the window frame (counting from 1), or null if no such row.
+ * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @param {import('../types.js').NumberValue} nth The 1-based window frame index.
+ * @returns {WindowNode}
+ */
+export function nth_value(expr: import("../types.js").ExprValue, nth: import("../types.js").NumberValue): WindowNode;
+import { WindowNode } from '../ast/window.js';

package/dist/types/index-types.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+export * from './types.js';

package/dist/types/index.d.ts

@@ -0,0 +1,53 @@
+export { AggregateNode } from "./ast/aggregate.js";
+export { BinaryOpNode } from "./ast/binary-op.js";
+export { CastNode } from "./ast/cast.js";
+export { ColumnParamNode } from "./ast/column-param.js";
+export { FragmentNode } from "./ast/fragment.js";
+export { FromClauseNode } from "./ast/from.js";
+export { FunctionNode } from "./ast/function.js";
+export { InOpNode } from "./ast/in-op.js";
+export { IntervalNode } from "./ast/interval.js";
+export { LiteralNode } from "./ast/literal.js";
+export { OrderByNode } from "./ast/order-by.js";
+export { ParamNode } from "./ast/param.js";
+export { SampleClauseNode } from "./ast/sample.js";
+export { SelectClauseNode } from "./ast/select.js";
+export { VerbatimNode } from "./ast/verbatim.js";
+export { WithClauseNode } from "./ast/with.js";
+export { cond } from "./functions/case.js";
+export { column } from "./functions/column.js";
+export { literal } from "./functions/literal.js";
+export { sql } from "./functions/sql-template-tag.js";
+export { rewrite } from "./visit/rewrite.js";
+export { walk } from "./visit/walk.js";
+export { loadExtension } from "./load/extension.js";
+export { bin1d } from "./transforms/bin-1d.js";
+export { bin2d } from "./transforms/bin-2d.js";
+export { binLinear1d } from "./transforms/bin-linear-1d.js";
+export { binLinear2d } from "./transforms/bin-linear-2d.js";
+export { lineDensity } from "./transforms/line-density.js";
+export { m4 } from "./transforms/m4.js";
+export { scaleTransform } from "./transforms/scales.js";
+export { isParamLike } from "./util/type-check.js";
+export { BetweenOpNode, NotBetweenOpNode } from "./ast/between-op.js";
+export { CaseNode, WhenNode } from "./ast/case.js";
+export { ColumnRefNode, ColumnNameRefNode, isColumnRef } from "./ast/column-ref.js";
+export { AndNode, OrNode } from "./ast/logical-op.js";
+export { SQLNode, ExprNode, isNode } from "./ast/node.js";
+export { DescribeQuery, Query, SelectQuery, SetOperation, isDescribeQuery, isQuery, isSelectQuery } from "./ast/query.js";
+export { TableRefNode, isTableRef } from "./ast/table-ref.js";
+export { UnaryOpNode, UnaryPosftixOpNode } from "./ast/unary-op.js";
+export { WindowClauseNode, WindowDefNode, WindowFrameNode, WindowFunctionNode, WindowNode } from "./ast/window.js";
+export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, 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 { cast, float32, float64, int32 } from "./functions/cast.js";
+export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms, interval } from "./functions/datetime.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";
+export { geojson, x, y, centroid, centroidX, centroidY } from "./functions/spatial.js";
+export { regexp_matches, contains, prefix, suffix, lower, upper, length } from "./functions/string.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 { collectAggregates, collectColumns, collectParams, isAggregateExpression } from "./visit/visitors.js";
+export { createTable, createSchema } from "./load/create.js";
+export { loadCSV, loadJSON, loadObjects, loadParquet, loadSpatial } from "./load/load.js";
+export { asLiteral, asNode, asTableRef, asVerbatim, over } from "./util/ast.js";

package/dist/types/load/create.d.ts

@@ -0,0 +1,8 @@
+export function createTable(name: any, query: any, { replace, temp, view }?: {
+    replace?: boolean;
+    temp?: boolean;
+    view?: boolean;
+}): string;
+export function createSchema(name: any, { strict }?: {
+    strict?: boolean;
+}): string;

package/dist/types/load/extension.d.ts

@@ -0,0 +1 @@
+export function loadExtension(name: any): string;

package/dist/types/load/load.d.ts

@@ -0,0 +1,12 @@
+export function load(method: any, tableName: any, fileName: any, options?: {}, defaults?: {}): string;
+export function loadCSV(tableName: any, fileName: any, options: any): string;
+export function loadJSON(tableName: any, fileName: any, options: any): string;
+export function loadParquet(tableName: any, fileName: any, options: any): string;
+/**
+ * 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.
+ * For TopoJSON, wet the layer option to indicate the feature to extract.
+ */
+export function loadSpatial(tableName: any, fileName: any, options?: {}): string;
+export function loadObjects(tableName: any, data: any, options?: {}): string;

package/dist/types/load/sql-from.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create a SQL query that embeds the given data for loading.
+ * @param {*} data The dataset as an array of objects.
+ * @param {object} [options] Loading options.
+ * @param {string[]|object} [options.columns] The columns to include.
+ *   If not specified, the keys of the first data object are used.
+ * @returns {string} SQL query string to load data.
+ */
+export function sqlFrom(data: any, { columns }?: {
+    columns?: string[] | object;
+}): string;

package/dist/types/transforms/bin-1d.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Compute binned values over a one-dimensional extent.
+ * @param {import('../types.js').ExprValue} x The expression to bin.
+ *  The expression must return numeric values. For example, to bin
+ *  datetime values, the input expression might map them to numeric
+ *  values such as milliseconds since the epoch.
+ * @param {number} lo The low value of the bin extent.
+ * @param {number} hi The high value of the bin extent.
+ * @param {number} bins The integer number of bins to use within the
+ *  defined binning extent.
+ * @param {boolean} [reverse] Flag indicating if bins should be
+ *  produced in reverse order from *hi* to *lo* (default `false`).
+ */
+export function bin1d(x: import("../types.js").ExprValue, lo: number, hi: number, bins: number, reverse?: boolean): import("../index.js").BinaryOpNode;

package/dist/types/transforms/bin-2d.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Perform aggregation over a binned 2D domain. This method takes expressions
+ * for the (non-truncated) x and y bin values; these expressions should be
+ * in units of grid indices, but can contain fractional components. The
+ * resulting query performs grouping and aggregation over the binned domain,
+ * and uses a 2D integer bin index of the form (xbin + num_xbins * ybin).
+ * @param {SelectQuery} q The input query. The FROM and WHERE clauses should
+ *  be added to the query separately, either before or after this method.
+ * @param {import('../types.js').ExprValue} xp The x bin expression.
+ * @param {import('../types.js').ExprValue} yp The y bin expression.
+ * @param {Record<string, import('../types.js').ExprValue>} aggs Named
+ *  aggregate expressions over bins.
+ * @param {number} xn The number of bins along the x dimension
+ * @param {string[]} groupby Group by expressions.
+ * @returns {SelectQuery} The input query, with binning expressions added.
+ */
+export function bin2d(q: SelectQuery, xp: import("../types.js").ExprValue, yp: import("../types.js").ExprValue, aggs: Record<string, import("../types.js").ExprValue>, xn: number, groupby: string[]): SelectQuery;
+import { SelectQuery } from '../ast/query.js';

package/dist/types/transforms/bin-linear-1d.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Perform linear binning in one dimension.
+ * @param {import('../ast/query.js').SelectQuery} query The base query to bin.
+ * @param {import('../types.js').ExprValue} x The expression to bin.
+ * @param {import('../types.js').ExprValue} [weight] The expression to weight by.
+ * @returns {Query}
+ */
+export function binLinear1d(query: import("../ast/query.js").SelectQuery, x: import("../types.js").ExprValue, weight?: import("../types.js").ExprValue): Query;
+import { Query } from '../ast/query.js';

package/dist/types/transforms/bin-linear-2d.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compute densities over a 2D domain using linear binning. The weight of
+ * each data point is linearly distributed over adjacent bins, providing
+ * a better base for subsequent kernel density estimation. This method takes
+ * expressions for the (non-truncated) x and y bin values; these expressions
+ * should be in units of grid indices, but can contain fractional components.
+ * @param {SelectQuery} q The input query. The FROM and WHERE clauses should
+ *  be added to the query separately, before this method is invoked.
+ * @param {import('../types.js').ExprValue} xp The x grid bin expression
+ * @param {import('../types.js').ExprValue} yp The y grid bin expression
+ * @param {import('../types.js').ExprValue | undefined} weight Point weights.
+ * @param {number} xn The number of x grid bins.
+ * @param {string[]} groupby Group by expressions.
+ * @returns {SelectQuery} A linear binning query for bin `index` and
+ *  aggregate `density` columns, in addition to any group by expressions.
+ */
+export function binLinear2d(q: SelectQuery, xp: import("../types.js").ExprValue, yp: import("../types.js").ExprValue, weight: import("../types.js").ExprValue | undefined, xn: number, groupby: string[]): SelectQuery;
+import { SelectQuery } from '../ast/query.js';

package/dist/types/transforms/line-density.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compute line segment densities over a gridded 2D domain. The returned
+ * query uses multiple subqueries (CTEs) to identify line segment end point
+ * pairs, perform line rasterization in-database, normalize arc lengths,
+ * and then sum results for all line series to produce a density map.
+ * Based on Moritz and Fisher's work: https://arxiv.org/abs/1808.06019
+ * @param {SelectQuery} q The base query over the data.
+ * @param {import('../types.js').ExprValue} x Bin expression for x dimension.
+ *  Provides gridded x coordinates, potentially with a fractional component.
+ * @param {import('../types.js').ExprValue} y Bin expression for x dimension.
+ *  Provides gridded y coordinates, potentially with a fractional component.
+ * @param {string[]} z Group by columns that segment data into individual line
+ *  series. An empty array indicates there is only a single line series.
+ * @param {number} xn The number of grid bins for the x dimension.
+ * @param {number} yn The number of grid bins for the y dimension.
+ * @param {string[]} [groupby] Additional group by expressions. Separate
+ *  line density maps are created for each of these groups.
+ * @param {boolean} [normalize=true] Flag toggling approximate arc-length
+ *  normalization to improve accuracy and reduce artifacts (default `true`).
+ * @returns {SelectQuery}
+ */
+export function lineDensity(q: SelectQuery, x: import("../types.js").ExprValue, y: import("../types.js").ExprValue, z: string[], xn: number, yn: number, groupby?: string[], normalize?: boolean): SelectQuery;
+import { SelectQuery } from '../ast/query.js';

package/dist/types/transforms/m4.d.ts

@@ -0,0 +1,18 @@
+/**
+ * M4 is an optimization for value-preserving time-series aggregation
+ * (https://www.vldb.org/pvldb/vol7/p797-jugel.pdf). This implementation uses
+ * an efficient version with a single scan and the aggregate functions
+ * argmin and argmax, following https://arxiv.org/pdf/2306.03714.pdf.
+ * This method can bin along either the *x* or *y* dimension, as determined
+ * by the caller-provided *bin* expression.
+ * @param {import('../types.js').FromExpr} input The base query or table.
+ * @param {import('../types.js').ExprValue} bin An expression that maps
+ *  time-series values to fractional pixel positions.
+ * @param {string} x The x dimension column name.
+ * @param {string} y The y dimension column name.
+ * @param {import('../ast/node.js').ExprNode[]} [groups] Additional
+ *  groupby columns, for example for faceted charts.
+ * @returns {Query} The resulting M4 query.
+ */
+export function m4(input: import("../types.js").FromExpr, bin: import("../types.js").ExprValue, x: string, y: string, groups?: import("../ast/node.js").ExprNode[]): Query;
+import { Query } from '../ast/query.js';

package/dist/types/transforms/scales.d.ts

@@ -0,0 +1 @@
+export function scaleTransform(options: any): any;

package/dist/types/types.d.ts

@@ -0,0 +1,59 @@
+import { ColumnRefNode } from './ast/column-ref.js';
+import { ExprNode, SQLNode } from './ast/node.js';
+import { TableRefNode } from './ast/table-ref.js';
+import { Query } from './ast/query.js';
+/**
+ * Interface representing a dynamic parameter value.
+ */
+export interface ParamLike {
+    /** The current parameter value. */
+    value: any;
+    /** Add an event listener callback. */
+    addEventListener(type: string, callback: EventCallback): void;
+    /** Remove an event listener callback. */
+    removeEventListener(type: string, callback: EventCallback): void;
+}
+/**
+ * Expression value input to SQL builder method.
+ */
+export type ExprValue = ExprNode | ParamLike | string | number | boolean | Date;
+/**
+ * Expression values that may be nested in arrays.
+ */
+export type ExprVarArgs = MaybeArray<ExprValue>;
+/**
+ * String-typed expression value.
+ */
+export type StringValue = ExprNode | ParamLike | string;
+/**
+ * Number-typed expression value.
+ */
+export type NumberValue = ExprNode | ParamLike | number;
+/**
+ * Event listener callback function.
+ */
+export type EventCallback = <T>(value: any) => Promise<T> | undefined;
+/**
+ * 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;
+/** Valid window function names. */
+export type WindowFunctionName = 'cume_dist' | 'dense_rank' | 'first_value' | 'lag' | 'last_value' | 'lead' | 'nth_value' | 'ntile' | 'percent_rank' | 'rank_dense' | 'rank' | 'row_number';
+export type MaybeArray<T> = T | T[];
+export type SelectEntry = string | ColumnRefNode | [string, ExprNode] | Record<string, ExprValue>;
+export type SelectExpr = MaybeArray<SelectEntry>;
+export type WithExpr = MaybeArray<Record<string, Query>>;
+export type FromEntry = string | TableRefNode | SQLNode | [string, SQLNode] | Record<string, string | SQLNode>;
+export type FromExpr = MaybeArray<FromEntry>;
+export type FilterExpr = MaybeArray<string | ExprNode>;
+export type GroupByExpr = MaybeArray<string | ExprNode>;
+export type OrderByExpr = MaybeArray<string | ExprNode>;

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

@@ -0,0 +1,60 @@
+/**
+ * Interpret a value as a SQL AST node. String values are assumed to be
+ * column references. All other primitive values are interpreted as
+ * SQL literals. Dynamic parameters are interpreted as param AST nodes,
+ * while existing AST nodes are left as-is.
+ * @param {*} value The value to interpret as a SQL AST node.
+ * @returns {ExprNode}
+ */
+export function asNode(value: any): ExprNode;
+/**
+ * Interpret a value as a verbatim SQL AST node. String values will be
+ * passed through to queries as verbatim text. All other primitive values
+ * are interpreted as SQL literals. Dynamic parameters are interpreted
+ * as param AST nodes, while existing AST nodes are left as-is.
+ * @param {*} value The value to interpret as a verbatim AST node.
+ * @returns {ExprNode}
+ */
+export function asVerbatim(value: any): ExprNode;
+/**
+ * Interpret a value as a literal AST node. All other primitive values
+ * are interpreted as SQL literals. Dynamic parameters are interpreted
+ * as param AST nodes, while existing AST nodes are left as-is.
+ * @param {*} value The value to interpret as a literal AST node.
+ * @returns {ExprNode}
+ */
+export function asLiteral(value: any): ExprNode;
+/**
+ * Interpret a value as a table reference AST node. String values are parsed
+ * assuming dot ('.') delimiters (as in `schema.table`). Array values are
+ * interpreted as pre-parsed name paths (as in `['schema', 'table']`). Any
+ * other values are left as-is.
+ * @param {string | string[] | TableRefNode} value The value to interpret as a
+ *  table reference AST node.
+ * @returns {TableRefNode}
+ */
+export function asTableRef(value: string | string[] | TableRefNode): TableRefNode;
+/**
+ * Parse a string as a column reference, potentially with
+ * dot ('.') delimited table, schema, and database references.
+ * @param {string} ref The column reference string.
+ * @returns {import('../ast/column-ref.js').ColumnRefNode}
+ */
+export function parseColumnRef(ref: string): import("../ast/column-ref.js").ColumnRefNode;
+/**
+ * Parse a string as a table reference, potentially with
+ * dot ('.') delimited schema and database references.
+ * @param {string} ref The table reference string.
+ * @returns {import('../ast/table-ref.js').TableRefNode}
+ */
+export function parseTableRef(ref: string): import("../ast/table-ref.js").TableRefNode;
+/**
+ * Create a new window definition node. The return value is an empty
+ * window definition. Use chained calls such as `partitionby` and `orderby`
+ * to specify the window settings.
+ * @returns {WindowDefNode}
+ */
+export function over(): WindowDefNode;
+import { ExprNode } from '../ast/node.js';
+import { TableRefNode } from '../ast/table-ref.js';
+import { WindowDefNode } from '../ast/window.js';

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

@@ -0,0 +1,54 @@
+/**
+ * Test if an AST node is a specific function call.
+ * @param {import('../ast/node.js').SQLNode} node The SQL AST node to test.
+ * @param {string} name The function name.
+ * @returns {node is FunctionNode}
+ */
+export function isFunctionCall(node: import("../ast/node.js").SQLNode, name: string): node is FunctionNode;
+/**
+ * Create a new function call AST node.
+ * @param {string} name The function name.
+ * @param  {...any} args The function arguments.
+ * @returns {FunctionNode}
+ */
+export function fn(name: string, ...args: any[]): FunctionNode;
+/**
+ * Create a new aggregate function AST node.
+ * @param {string} name The function name.
+ * @param  {...any} args The function arguments.
+ * @returns {AggregateNode}
+ */
+export function aggFn(name: string, ...args: any[]): AggregateNode;
+/**
+ * Create a new window AST node. The output node has an empty window
+ * definition. Use chained calls such as `partitionby` and `orderby`
+ * to specify the window settings.
+ * @param {import('../types.js').WindowFunctionName} name The function name.
+ * @param  {...any} args The function arguments.
+ * @returns {WindowNode}
+ */
+export function winFn(name: import("../types.js").WindowFunctionName, ...args: any[]): WindowNode;
+/**
+ * Process a list of expression inputs. Nested arrays are flattened,
+ * null results are removed, and each input is cast (as needed) to
+ * be a proper SQL AST node. By default, strings are assumed to be
+ * column names, while other primitive values map to SQL literals.
+ * Use an alternative *cast* function to change this behavior.
+ * @param {any[]} list The list of expression inputs.
+ * @param {function} [cast] A function that casts an input value
+ *  to a desired type. By default, `asNode` is used to coerce
+ *  inputs to AST nodes as needed.
+ * @returns {ReturnType<cast>[]}
+ */
+export function exprList(list: any[], cast?: Function): ReturnType<Function>[];
+/**
+ * Process a list of function arguments, stripping any undefined
+ * values from the end of the list.
+ * @template T
+ * @param {T[]} list The input function arguments.
+ * @returns {T[]} The prepared argument list.
+ */
+export function argsList<T>(list: T[]): T[];
+import { FunctionNode } from '../ast/function.js';
+import { AggregateNode } from '../ast/aggregate.js';
+import { WindowNode } from '../ast/window.js';

package/dist/types/util/string.d.ts

@@ -0,0 +1,3 @@
+export function parseIdentifier(id: any): any;
+export function quoteIdentifier(value: any): string;
+export function unquote(s: any): any;

package/dist/types/util/type-check.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Check if a value is a string.
+ * @param {*} value The value to check.
+ * @returns {value is string}
+ */
+export function isString(value: any): value is string;
+/**
+ * Check if a value is an array.
+ * @param {*} value The value to check.
+ * @returns {value is Array}
+ */
+export function isArray(value: any): value is any[];
+/**
+ * Check if a value is a dynamic parameter.
+ * @param {*} value The value to check.
+ * @returns {value is import('../types.js').ParamLike}
+ */
+export function isParamLike(value: any): value is import("../types.js").ParamLike;