@uwdata/mosaic-sql 0.16.2 → 0.18.0

package/src/functions/numeric.js

@@ -1,143 +0,0 @@
-/**
- * @import { FunctionNode } from '../ast/function.js'
- * @import { ExprValue } from '../types.js'
- */
-import { fn } from '../util/function.js';
-
-/**
- * Return true if the floating point value is not a number, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isNaN(expr) {
-  return fn('isnan', expr);
-}
-
-/**
- * Return true if the floating point value is finite, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isFinite(expr) {
-  return fn('isfinite', expr);
-}
-
-/**
- * Return true if the floating point value is infinite, false otherwise.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function isInfinite(expr) {
-  return fn('isinf', expr);
-}
-
-/**
- * Selects the largest value.
- * @param {...ExprValue} expr The input expressions.
- * @returns {FunctionNode}
- */
-export function greatest(...expr) {
-  return fn('greatest', ...expr);
-}
-
-/**
- * Selects the smallest value.
- * @param {...ExprValue} expr The input expressions.
- * @returns {FunctionNode}
- */
-export function least(...expr) {
-  return fn('least', ...expr);
-}
-
-/**
- * Compute the exponentional function `e ** expr`.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function exp(expr) {
-  return fn('exp', expr);
-}
-
-/**
- * Compute a base 10 logarithm.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function log(expr) {
-  return fn('log', expr);
-}
-
-/**
- * Compute a natural logarithm.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function ln(expr) {
-  return fn('ln', expr);
-}
-
-/**
- * Compute the sign of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function sign(expr) {
-  return fn('sign', expr);
-}
-
-/**
- * Compute the absolute value of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function abs(expr) {
-  return fn('abs', expr);
-}
-
-/**
- * Compute the square root of a number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function sqrt(expr) {
-  return fn('sqrt', expr);
-}
-
-/**
- * Rounds the number up.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function ceil(expr) {
-  return fn('ceil', expr);
-}
-
-/**
- * Rounds the number down.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function floor(expr) {
-  return fn('floor', expr);
-}
-
-/**
- * Round to the given decimal places.
- * @param {ExprValue} expr The input number.
- * @param {ExprValue} [places] The decimal places.
- *  Negative values are allowed, to round to tens, hundreds, etc.
- *  If unspecified, defaults to zero.
- * @returns {FunctionNode}
- */
-export function round(expr, places) {
-  return fn('round', expr, places);
-}
-
-/**
- * Truncates the number.
- * @param {ExprValue} expr The input number.
- * @returns {FunctionNode}
- */
-export function trunc(expr) {
-  return fn('trunc', expr);
-}

package/src/functions/operators.js

@@ -1,301 +0,0 @@
-/**
- * @import { ExprValue, ExprVarArgs } from '../types.js'
- */
-import { BetweenOpNode, NotBetweenOpNode } from '../ast/between-op.js';
-import { BinaryOpNode } from '../ast/binary-op.js';
-import { InOpNode } from '../ast/in-op.js';
-import { AndNode, OrNode } from '../ast/logical-op.js';
-import { UnaryOpNode, UnaryPosftixOpNode } from '../ast/unary-op.js';
-import { asNode } from '../util/ast.js';
-import { exprList } from '../util/function.js';
-
-function unaryOp(op, expr) {
-  return new UnaryOpNode(op, asNode(expr));
-}
-
-function unaryPostfixOp(op, expr) {
-  return new UnaryPosftixOpNode(op, asNode(expr));
-}
-
-function binaryOp(op, left, right) {
-  return new BinaryOpNode(op, asNode(left), asNode(right));
-}
-
-function betweenOp(expr, extent, negate = false) {
-  const Op = negate ? NotBetweenOpNode : BetweenOpNode;
-  return new Op(asNode(expr), extent?.map(asNode));
-}
-
-/**
- * Logical and (AND) operator.
- * @param {...ExprVarArgs} clauses The input expressions.
- * @returns {AndNode}
- */
-export function and(...clauses) {
-  return new AndNode(exprList(clauses));
-}
-
-/**
- * Logical or (OR) operator.
- * @param {...ExprVarArgs} clauses The input expressions.
- * @returns {OrNode}
- */
-export function or(...clauses) {
-  return new OrNode(exprList(clauses));
-}
-
-/**
- * Logical not (NOT) operator.
- * @param {ExprValue} expr The expression to negate.
- * @returns {UnaryOpNode}
- */
-export function not(expr) {
-  return unaryOp('NOT', expr);
-}
-
-/**
- * Null check (IS NULL) operator.
- * @param {ExprValue} expr The expression to test.
- * @returns {UnaryPosftixOpNode}
- */
-export function isNull(expr) {
-  return unaryPostfixOp('IS NULL', expr);
-}
-
-/**
- * Non-null check (IS NOT NULL) operator.
- * @param {ExprValue} expr The expression to test.
- * @returns {UnaryPosftixOpNode}
- */
-export function isNotNull(expr) {
-  return unaryPostfixOp('IS NOT NULL', expr);
-}
-
-/**
- * Bitwise not (~) operator.
- * @param {ExprValue} expr The input expression.
- * @returns {UnaryOpNode}
- */
-export function bitNot(expr) {
-  return unaryOp('~', expr);
-}
-
-/**
- * Bitwise and (&) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function bitAnd(left, right) {
-  return binaryOp('&', left, right);
-}
-
-/**
- * Bitwise or (|) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function bitOr(left, right) {
-  return binaryOp('|', left, right);
-}
-
-/**
- * Bit shift left (<<) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function bitLeft(left, right) {
-  return binaryOp('<<', left, right);
-}
-
-/**
- * Bit shift right (>>) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function bitRight(left, right) {
-  return binaryOp('>>', left, right);
-}
-
-/**
- * Addition (+) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function add(left, right) {
-  return binaryOp('+', left, right);
-}
-
-/**
- * Subtraction (-) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function sub(left, right) {
-  return binaryOp('-', left, right);
-}
-
-/**
- * Multiplication (*) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function mul(left, right) {
-  return binaryOp('*', left, right);
-}
-
-/**
- * Division (/) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function div(left, right) {
-  return binaryOp('/', left, right);
-}
-
-/**
- * Integer division (//) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function idiv(left, right) {
-  return binaryOp('//', left, right);
-}
-
-/**
- * Modulo (%) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function mod(left, right) {
-  return binaryOp('%', left, right);
-}
-
-/**
- * Exponentiation (**) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function pow(left, right) {
-  return binaryOp('**', left, right);
-}
-
-/**
- * Equality comparision (=) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function eq(left, right) {
-  return binaryOp('=', left, right);
-}
-
-/**
- * Non-equality comparision (<>) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function neq(left, right) {
-  return binaryOp('<>', left, right);
-}
-
-/**
- * Less-than comparision (<) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function lt(left, right) {
-  return binaryOp('<', left, right);
-}
-
-/**
- * Greater-than comparision (>) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function gt(left, right) {
-  return binaryOp('>', left, right);
-}
-
-/**
- * Less-than or equal comparision (<=) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function lte(left, right) {
-  return binaryOp('<=', left, right);
-}
-
-/**
- * Greater-than or equal comparision (>=) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function gte(left, right) {
-  return binaryOp('>=', left, right);
-}
-
-/**
- * Null-inclusive non-equality (IS DISTINCT FROM) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function isDistinct(left, right) {
-  return binaryOp('IS DISTINCT FROM', left, right);
-}
-
-/**
- * Null-inclusive equality (IS NOT DISTINCT FROM) operator.
- * @param {ExprValue} left The left argument.
- * @param {ExprValue} right The right argument.
- * @returns {BinaryOpNode}
- */
-export function isNotDistinct(left, right) {
-  return binaryOp('IS NOT DISTINCT FROM', left, right);
-}
-
-/**
- * Range inclusion (BETWEEN) operator.
- * @param {ExprValue} expr The expression to test.
- * @param {ExprValue[]} extent The range extent.
- * @returns {BetweenOpNode}
- */
-export function isBetween(expr, extent) {
-  return betweenOp(expr, extent, false);
-}
-
-/**
- * Range exclusion (NOT BETWEEN) operator.
- * @param {ExprValue} expr The expression to test.
- * @param {ExprValue[]} extent The range extent.
- * @returns {NotBetweenOpNode}
- */
-export function isNotBetween(expr, extent) {
-  return betweenOp(expr, extent, true);
-}
-
-/**
- * Set inclusion (IN) operator.
- * @param {ExprValue} expr The expression to test.
- * @param {ExprValue[]} values The included values.
- * @returns {InOpNode}
- */
-export function isIn(expr, values) {
-  return new InOpNode(asNode(expr), values.map(asNode));
-}

package/src/functions/order-by.js

@@ -1,27 +0,0 @@
-/**
- * @import { ExprValue } from '../types.js'
- */
-import { OrderByNode } from '../ast/order-by.js';
-import { asNode } from '../util/ast.js';
-
-/**
- * Indicate ascending sort order for an expression.
- * @param {ExprValue} expr An expression to order by.
- * @param {boolean | undefined} [nullsFirst] Flag indicating if null values
- *  should be sorted first.
- * @returns {OrderByNode}
- */
-export function asc(expr, nullsFirst) {
-  return new OrderByNode(asNode(expr), false, nullsFirst);
-}
-
-/**
- * Indicate descending sort order for an expression.
- * @param {ExprValue} expr An expression to order by.
- * @param {boolean | undefined} [nullsFirst] Flag indicating if null values
- *  should be sorted first.
- * @returns {OrderByNode}
- */
-export function desc(expr, nullsFirst) {
-  return new OrderByNode(asNode(expr), true, nullsFirst);
-}

package/src/functions/spatial.js

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

package/src/functions/string.js

@@ -1,85 +0,0 @@
-/**
- * @import { FunctionNode } from '../ast/function.js'
- * @import { ExprValue, StringValue } from '../types.js'
- */
-import { asLiteral } from '../util/ast.js';
-import { argsList, fn } from '../util/function.js';
-
-function strFn(name, expr, ...args) {
-  return fn(name, expr, ...(argsList(args).map(asLiteral)));
-}
-
-/**
- * Function that returns true if a string contains a regexp pattern,
- * false otherwise.
- * @param {ExprValue} string The string match against.
- * @param {StringValue} pattern The regular expression pattern to match.
- * @param {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, pattern, options) {
-  return strFn('regexp_matches', string, pattern, options);
-}
-
-/**
- * Function that returns true if search_string is found within string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function contains(string, search_string) {
-  return strFn('contains', string, search_string);
-}
-
-/**
- * Function that returns true if string begins with search_string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function prefix(string, search_string) {
-  return strFn('starts_with', string, search_string);
-}
-
-/**
- * Function that returns true if string ends with search_string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function suffix(string, search_string) {
-  return strFn('ends_with', string, search_string);
-}
-
-/**
- * Function that converts string to lower case.
- * @param {ExprValue} string The string to convert.
- * @returns {FunctionNode}
- */
-export function lower(string) {
-  return strFn('lower', string);
-}
-
-/**
- * Function that converts string to upper case.
- * @param {ExprValue} string The string to convert.
- * @returns {FunctionNode}
- */
-export function upper(string) {
-  return strFn('upper', string);
-}
-
-/**
- * Function that returns the number of characters in string.
- * @param {ExprValue} value The string to measure.
- * @returns {FunctionNode}
- */
-export function length(value) {
-  return strFn('length', value);
-}

package/src/functions/util.js

@@ -1,14 +0,0 @@
-/**
- * @import { FunctionNode } from '../ast/function.js'
- * @import { ExprValue } from '../types.js'
- */
-import { fn } from '../util/function.js';
-
-/**
- * Returns the first non-null argument.
- * @param {...ExprValue} expr The input expressions.
- * @returns {FunctionNode}
- */
-export function coalesce(...expr) {
-  return fn('coalesce', ...expr);
-}

package/src/index-types.ts

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

package/src/load/extension.js

@@ -1,3 +0,0 @@
-export function loadExtension(name) {
-  return `INSTALL ${name}; LOAD ${name}`;
-}

package/src/transforms/bin-date.js

@@ -1,37 +0,0 @@
-/**
- * @import { ExprNode } from '../ast/node.js'
- * @import { ExprValue, TimeUnit } from '../types.js'
- */
-import { dateBin, interval } from '../functions/datetime.js';
-import { add } from '../functions/operators.js';
-import { timeInterval } from './util/time-interval.js';
-
-/**
- * @typedef {object} BinDateOptions
- * @property {TimeUnit} [interval] A string indicating a time interval
- *  unit, such as 'year', 'day', or 'hour'.
- * @property {number} [step] The number of time interval steps to
- *  take, such as 2 years or 3 months.
- * @property {number} [offset] The number of bin steps (default 0) by
- *  which to offset the result.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- */
-
-/**
- * Return a SQL expression for date/time bins.
- * @param {ExprValue} field The column or expression to bin.
- * @param {[Date|number, Date|number]} extent The min/max extent over which to bin.
- * @param {BinDateOptions} [options] Datetime binning options.
- * @returns {ExprNode}
- */
-export function binDate(field, extent, options = {}) {
-  const { offset = 0 } = options;
-
-  // use interval if provided, otherwise determine from extent
-  const { unit, step = 1 } = options.interval
-    ? { unit: options.interval, step: options.step }
-    : timeInterval(extent[0], extent[1], options.steps || 40);
-  const bin = dateBin(field, unit, step);
-  return offset ? add(bin, interval(unit, offset * step)) : bin;
-}