@uwdata/mosaic-sql 0.10.0 → 0.12.0

package/src/ast/from.js

@@ -0,0 +1,40 @@
+import { FROM_CLAUSE } from '../constants.js';
+import { quoteIdentifier } from '../util/string.js';
+import { SQLNode } from './node.js';
+import { isQuery } from './query.js';
+import { isTableRef } from './table-ref.js';
+
+export class FromClauseNode extends SQLNode {
+  /**
+   * Instantiate a from node.
+   * @param {SQLNode} expr The from expression.
+   * @param {string} alias The output name.
+   */
+  constructor(expr, alias) {
+    super(FROM_CLAUSE);
+    /**
+     * The from expression.
+     * @type {SQLNode}
+     * @readonly
+     */
+    this.expr = expr;
+    /**
+     * The output name.
+     * @type {string}
+     * @readonly
+     */
+    this.alias = alias;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { expr, alias } = this;
+    const ref = isQuery(expr) ? `(${expr})` : `${expr}`;
+    return alias && !(isTableRef(expr) && expr.table.join('.') === alias)
+      ? `${ref} AS ${quoteIdentifier(alias)}`
+      : `${ref}`;
+  }
+}

package/src/ast/function.js

@@ -0,0 +1,34 @@
+import { FUNCTION } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class FunctionNode extends ExprNode {
+  /**
+   * Instantiate a function node.
+   * @param {string} name The function name.
+   * @param {ExprNode[]} [args=[]] The function arguments.
+   */
+  constructor(name, args = []) {
+    super(FUNCTION);
+    /**
+     * The function name.
+     * @type {string}
+     * @readonly
+     */
+    this.name = name;
+    /**
+     * The function arguments.
+     * @type {ExprNode[]}
+     * @readonly
+     */
+    this.args = args;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { name, args } = this;
+    return `${name}(${args.join(', ')})`;
+  }
+}

package/src/ast/in-op.js

@@ -0,0 +1,33 @@
+import { IN_OPERATOR } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class InOpNode extends ExprNode {
+  /**
+   * Instantiate an in operator node.
+   * @param {ExprNode} expr The input expression.
+   * @param {ExprNode[]} values The value set.
+   */
+  constructor(expr, values) {
+    super(IN_OPERATOR);
+    /**
+     * The input expression.
+     * @type {ExprNode}
+     * @readonly
+     */
+    this.expr = expr;
+    /**
+     * The value set.
+     * @type {ExprNode[]}
+     * @readonly
+     */
+    this.values = values;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `(${this.expr} IN (${this.values.join(', ')}))`;
+  }
+}

package/src/ast/interval.js

@@ -0,0 +1,33 @@
+import { INTERVAL } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class IntervalNode extends ExprNode {
+  /**
+   * Instantiate an interval node.
+   * @param {string} name The interval name.
+   * @param {number} [steps=1] The interval steps.
+   */
+  constructor(name, steps = 1) {
+    super(INTERVAL);
+    /**
+     * The interval name.
+     * @type {string}
+     * @readonly
+     */
+    this.name = name;
+    /**
+     * The interval steps.
+     * @type {number}
+     * @readonly
+     */
+    this.steps = steps;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return `INTERVAL ${this.steps} ${this.name}`;
+  }
+}

package/src/ast/literal.js

@@ -0,0 +1,55 @@
+import { LITERAL } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class LiteralNode extends ExprNode {
+  /**
+   * Instantiate an literal node.
+   * @param {*} value The literal value.
+   */
+  constructor(value) {
+    super(LITERAL);
+    /**
+     * The literal value.
+     * @type {any}
+     * @readonly
+     */
+    this.value = value;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return literalToSQL(this.value);
+  }
+}
+
+export function literalToSQL(value) {
+  switch (typeof value) {
+    case 'number':
+      return Number.isFinite(value) ? `${value}` : 'NULL';
+    case 'string':
+      return `'${value.replace(`'`, `''`)}'`;
+    case 'boolean':
+      return value ? 'TRUE' : 'FALSE';
+    default:
+      if (value == null) {
+        return 'NULL';
+      } else if (value instanceof Date) {
+        const ts = +value;
+        if (Number.isNaN(ts)) return 'NULL';
+        const y = value.getUTCFullYear();
+        const m = value.getUTCMonth();
+        const d = value.getUTCDate();
+        return ts === Date.UTC(y, m, d)
+          ? `DATE '${y}-${m+1}-${d}'` // utc date
+          : `epoch_ms(${ts})`; // timestamp
+      } else if (value instanceof RegExp) {
+        return `'${value.source}'`;
+      } else {
+        // otherwise rely on string coercion
+        return `${value}`;
+      }
+  }
+}

package/src/ast/logical-op.js

@@ -0,0 +1,67 @@
+import { LOGICAL_OPERATOR } from '../constants.js';
+import { ExprNode } from './node.js';
+
+/**
+ * @template {ExprNode} T
+ */
+export class LogicalOpNode extends ExprNode {
+  /**
+   * Instantiate a logical operator node.
+   * @param {string} op The logical operation.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(op, clauses) {
+    super(LOGICAL_OPERATOR);
+    /**
+     * The logical operator.
+     * @type {string}
+     * @readonly
+     */
+    this.op = op;
+    /**
+     * The input clause expressions.
+     * @type {T[]}
+     * @readonly
+     */
+    this.clauses = clauses;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const c = this.clauses;
+    return c.length === 0 ? ''
+      : c.length === 1 ? `${c[0]}`
+      : `(${c.join(` ${this.op} `)})`;
+  }
+}
+
+/**
+ * @template {ExprNode} T
+ * @extends {LogicalOpNode<T>}
+ */
+export class AndNode extends LogicalOpNode {
+  /**
+   * Instantiate a logical AND operator node.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(clauses) {
+    super('AND', clauses);
+  }
+}
+
+/**
+ * @template {ExprNode} T
+ * @extends {LogicalOpNode<T>}
+ */
+export class OrNode extends LogicalOpNode {
+  /**
+   * Instantiate a logical OR operator node.
+   * @param {T[]} clauses The input clause expressions.
+   */
+  constructor(clauses) {
+    super('OR', clauses);
+  }
+}

package/src/ast/node.js

@@ -0,0 +1,29 @@
+/**
+ * Check if a value is a SQL AST node.
+ * @param {*} value The value to check.
+ * @returns {value is SQLNode}
+ */
+export function isNode(value) {
+  return value instanceof SQLNode;
+}
+
+export class SQLNode {
+  /**
+   * Instantiate a SQL AST node.
+   * @param {string} type The SQL AST node type.
+   */
+  constructor(type) {
+    /**
+     * The SQL AST node type.
+     * @type {string}
+     * @readonly
+     */
+    this.type = type;
+  }
+}
+
+/**
+ * AST node corresponding to an individual expression.
+ */
+export class ExprNode extends SQLNode {
+}

package/src/ast/order-by.js

@@ -0,0 +1,48 @@
+import { ORDER_BY } from '../constants.js';
+import { ExprNode } from './node.js';
+
+export class OrderByNode extends ExprNode {
+  /**
+   * Instantiate an order by entry node.
+   * @param {ExprNode} expr The expression to order by.
+   * @param {boolean | undefined} [desc] Flag indicating descending order.
+   * @param {boolean | undefined} [nullsFirst] Flag indicating if null
+   *  values should be sorted first.
+   */
+  constructor(expr, desc, nullsFirst) {
+    super(ORDER_BY);
+    /**
+     * The expression to order by.
+     * @type {ExprNode}
+     * @readonly
+     */
+    this.expr = expr;
+    /**
+     * Flag indicating descending order.
+     * @type {boolean | undefined}
+     * @readonly
+     */
+    this.desc = desc;
+    /**
+     * Flag indicating if null values should be sorted first.
+     * @type {boolean | undefined}
+     * @readonly
+     */
+    this.nullsFirst = nullsFirst;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    const { expr, desc, nullsFirst } = this;
+    const dir = desc ? ' DESC'
+      : desc === false ? ' ASC'
+      : '';
+    const nf = nullsFirst ? ' NULLS FIRST'
+      : nullsFirst === false ? ' NULLS LAST'
+      : '';
+    return `${expr}${dir}${nf}`;
+  }
+}

package/src/ast/param.js

@@ -0,0 +1,35 @@
+import { PARAM } from '../constants.js';
+import { literalToSQL } from './literal.js';
+import { ExprNode } from './node.js';
+
+export class ParamNode extends ExprNode {
+  /**
+   * Instantiate a param node with a dynamic parameter.
+   * @param {import('../types.js').ParamLike} param The dynamic parameter.
+   */
+  constructor(param) {
+    super(PARAM);
+    /**
+     * The dynamic parameter.
+     * @type {import('../types.js').ParamLike}
+     * @readonly
+     */
+    this.param = param;
+  }
+
+  /**
+   * Returns the current parameter value.
+   * @returns {*}
+   */
+  get value() {
+    return this.param.value;
+  }
+
+  /**
+   * Generate a SQL query string for this node.
+   * @returns {string}
+   */
+  toString() {
+    return literalToSQL(this.value);
+  }
+}