@uwdata/mosaic-core 0.9.0 → 0.10.0

package/src/SelectionClause.js

@@ -24,7 +24,10 @@ import { MosaicClient } from './MosaicClient.js';
  *  cross-filtering contexts.
  * @returns {SelectionClause} The generated selection clause.
  */
-export function point(field, value, { source, clients = undefined }) {
+export function clausePoint(field, value, {
+  source,
+  clients = source ? new Set([source]) : undefined
+}) {
   /** @type {SQLExpression | null} */
   const predicate = value !== undefined
     ? isNotDistinct(field, literal(value))
@@ -50,7 +53,10 @@ export function point(field, value, { source, clients = undefined }) {
  *  cross-filtering contexts.
  * @returns {SelectionClause} The generated selection clause.
  */
-export function points(fields, value, { source, clients = undefined }) {
+export function clausePoints(fields, value, {
+  source,
+  clients = source ? new Set([source]) : undefined
+}) {
   /** @type {SQLExpression | null} */
   let predicate = null;
   if (value) {
@@ -83,13 +89,17 @@ export function points(fields, value, { source, clients = undefined }) {
  * @param {number} [options.pixelSize=1] The interactive pixel size.
  * @returns {SelectionClause} The generated selection clause.
  */
-export function interval(field, value, {
-  source, clients, bin, scale, pixelSize = 1
+export function clauseInterval(field, value, {
+  source,
+  clients = source ? new Set([source]) : undefined,
+  bin,
+  scale,
+  pixelSize = 1
 }) {
   /** @type {SQLExpression | null} */
   const predicate = value != null ? isBetween(field, value) : null;
   /** @type {import('./util/selection-types.js').IntervalMetadata} */
-  const meta = { type: 'interval', scales: [scale], bin, pixelSize };
+  const meta = { type: 'interval', scales: scale && [scale], bin, pixelSize };
   return { meta, source, clients, value, predicate };
 }
 
@@ -108,8 +118,12 @@ export function interval(field, value, {
  * @param {number} [options.pixelSize=1] The interactive pixel size.
  * @returns {SelectionClause} The generated selection clause.
  */
-export function intervals(fields, value, {
-  source, clients, bin, scales = [], pixelSize = 1
+export function clauseIntervals(fields, value, {
+  source,
+  clients = source ? new Set([source]) : undefined,
+  bin,
+  scales = [],
+  pixelSize = 1
 }) {
   /** @type {SQLExpression | null} */
   const predicate = value != null
@@ -135,7 +149,7 @@ const MATCH_METHODS = { contains, prefix, suffix, regexp: regexp_matches };
  *  text matching method to use. Defaults to `'contains'`.
  * @returns {SelectionClause} The generated selection clause.
  */
-export function match(field, value, {
+export function clauseMatch(field, value, {
   source, clients = undefined, method = 'contains'
 }) {
   let fn = MATCH_METHODS[method];

package/src/index.js

@@ -3,18 +3,27 @@ export { Coordinator, coordinator } from './Coordinator.js';
 export { Selection, isSelection } from './Selection.js';
 export { Param, isParam } from './Param.js';
 export { Priority } from './QueryManager.js';
-export { point, points, interval, intervals, match } from './SelectionClause.js';
 
 export { restConnector } from './connectors/rest.js';
 export { socketConnector } from './connectors/socket.js';
 export { wasmConnector } from './connectors/wasm.js';
 
+export {
+  clauseInterval,
+  clauseIntervals,
+  clausePoint,
+  clausePoints,
+  clauseMatch
+} from './SelectionClause.js';
+
 export {
   isArrowTable,
   convertArrowArrayType,
   convertArrowValue,
   convertArrowColumn
 } from './util/convert-arrow.js'
+
 export { distinct } from './util/distinct.js';
 export { synchronizer } from './util/synchronizer.js';
 export { throttle } from './util/throttle.js';
+export { toDataColumns } from './util/to-data-columns.js'

package/src/util/AsyncDispatch.js

@@ -1,8 +1,7 @@
 /**
- * Event dispatcher supporting asynchronous updates.
- * If an event handler callback returns a Promise, this dispatcher will
- * wait for all such Promises to settle before dispatching future events
- * of the same type.
+ * Event dispatcher supporting asynchronous updates. If an event handler
+ * callback returns a Promise, the dispatcher waits for all such Promises
+ * to settle before dispatching future events of the same type.
  */
 export class AsyncDispatch {
 
@@ -63,7 +62,7 @@ export class AsyncDispatch {
    * queue of unemitted event values prior to enqueueing a new value.
    * This default implementation simply returns null, indicating that
    * any other unemitted event values should be dropped (that is, all
-   * queued events are filtered)
+   * queued events are filtered).
    * @param {string} type The event type.
    * @param {*} value The new event value that will be enqueued.
    * @returns {(value: *) => boolean|null} A dispatch queue filter
@@ -83,6 +82,17 @@ export class AsyncDispatch {
     entry?.queue.clear();
   }
 
+  /**
+   * Returns a promise that resolves when any pending updates complete for
+   * the event of the given type currently being processed. The Promise will
+   * resolve immediately if the queue for the given event type is empty.
+   * @param {string} type The event type to wait for.
+   * @returns {Promise} A pending event promise.
+   */
+  async pending(type) {
+    await this._callbacks.get(type)?.pending;
+  }
+
   /**
    * Emit an event value to listeners for the given event type.
    * If a previous emit has not yet resolved, the event value

package/src/util/index-columns.js

@@ -1,21 +1,20 @@
 import { Query, agg, sql } from '@uwdata/mosaic-sql';
 import { MosaicClient } from '../MosaicClient.js';
 
-export const NO_INDEX = { from: NaN };
-
 /**
  * Determine data cube index columns for a given Mosaic client.
  * @param {MosaicClient} client The Mosaic client.
  * @returns An object with necessary column data to generate data
- *  cube index columns, null if an invalid or unsupported expression
- *  is encountered, or NO_INDEX if the client is not indexable.
+ *  cube index columns, or null if the client is not indexable or
+ *  the client query contains an invalid or unsupported expression.
  */
 export function indexColumns(client) {
-  if (!client.filterIndexable) return NO_INDEX;
+  if (!client.filterIndexable) return null;
   const q = client.query();
   const from = getBaseTable(q);
-  if (typeof from !== 'string' || !q.groupby) return NO_INDEX;
-  const g = new Set(q.groupby().map(c => c.column));
+
+  // bail if no base table or the query is not analyzable
+  if (typeof from !== 'string' || !q.select) return null;
 
   const aggr = []; // list of output aggregate columns
   const dims = []; // list of grouping dimension columns
@@ -127,11 +126,14 @@ export function indexColumns(client) {
 
       // otherwise, check if dimension
       default:
-        if (g.has(as)) dims.push(as);
+        if (!aggregate) dims.push(as);
         else return null; // unsupported aggregate
     }
   }
 
+  // bail if the query has no aggregates
+  if (!aggr.length) return null;
+
   return { from, dims, aggr, aux };
 }
 

package/src/util/query-result.js

@@ -1,9 +1,42 @@
-export function queryResult() {
-  let resolve;
-  let reject;
-  const p = new Promise((r, e) => { resolve = r; reject = e; });
-  return Object.assign(p, {
-    fulfill: value => (resolve(value), p),
-    reject: err => (reject(err), p)
-  });
+/**
+ * A query result Promise that can allows external callers
+ * to resolve or reject the Promise.
+ */
+export class QueryResult extends Promise {
+  /**
+   * Create a new query result Promise.
+   */
+  constructor() {
+    let resolve;
+    let reject;
+    super((r, e) => {
+      resolve = r;
+      reject = e;
+    });
+    this._resolve = resolve;
+    this._reject = reject;
+  }
+
+  /**
+   * Resolve the result Promise with the provided value.
+   * @param {*} value The result value.
+   * @returns {this}
+   */
+  fulfill(value) {
+    this._resolve(value);
+    return this;
+  }
+
+  /**
+   * Rejects the result Promise with the provided error.
+   * @param {*} error The error value.
+   * @returns {this}
+   */
+  reject(error) {
+    this._reject(error);
+    return this;
+  }
 }
+
+// necessary to make Promise subclass act like a Promise
+QueryResult.prototype.constructor = Promise;

package/src/util/to-data-columns.js

@@ -0,0 +1,71 @@
+import { convertArrowColumn, isArrowTable } from './convert-arrow.js';
+
+/**
+ * @typedef {Array | Int8Array | Uint8Array | Uint8ClampedArray
+ *  | Int16Array | Uint16Array | Int32Array | Uint32Array
+ *  | Float32Array | Float64Array
+ * } Arrayish - an Array or TypedArray
+ */
+
+/**
+ * @typedef {
+ *  | { numRows: number, columns: Record<string,Arrayish> }
+ *  | { numRows: number, values: Arrayish; }
+ * } DataColumns
+*/
+
+/**
+ * Convert input data to a set of column arrays.
+ * @param {any} data The input data.
+ * @returns {DataColumns} An object with named column arrays.
+ */
+export function toDataColumns(data) {
+  return isArrowTable(data)
+    ? arrowToColumns(data)
+    : arrayToColumns(data);
+}
+
+/**
+ * Convert an Arrow table to a set of column arrays.
+ * @param {import('apache-arrow').Table} data An Apache Arrow Table.
+ * @returns {DataColumns} An object with named column arrays.
+ */
+function arrowToColumns(data) {
+  const { numRows, numCols, schema: { fields } } = data;
+  const columns = {};
+
+  for (let col = 0; col < numCols; ++col) {
+    const name = fields[col].name;
+    if (columns[name]) {
+      console.warn(`Redundant column name "${name}". Skipping...`);
+    } else {
+      columns[name] = convertArrowColumn(data.getChildAt(col));
+    }
+  }
+
+  return { numRows, columns };
+}
+
+/**
+ * Convert an array of values to a set of column arrays.
+ * If the array values are objects, build out named columns.
+ * We use the keys of the first object as the column names.
+ * Otherwise, use a special "values" array.
+ * @param {object[]} data An array of data objects.
+ * @returns {DataColumns} An object with named column arrays.
+ */
+function arrayToColumns(data) {
+  const numRows = data.length;
+  if (typeof data[0] === 'object') {
+    const names = numRows ? Object.keys(data[0]) : [];
+    const columns = {};
+    if (names.length > 0) {
+      names.forEach(name => {
+        columns[name] = data.map(d => d[name]);
+      });
+    }
+    return { numRows, columns };
+  } else {
+    return { numRows, values: data };
+  }
+}

package/src/FilterGroup.js

@@ -1,81 +0,0 @@
-import { Coordinator } from './Coordinator.js';
-import { DataCubeIndexer } from './DataCubeIndexer.js';
-import { MosaicClient } from './MosaicClient.js';
-import { Selection } from './Selection.js';
-
-export class FilterGroup {
-  /**
-   * @param {Coordinator} coordinator The Mosaic coordinator.
-   * @param {Selection} selection The shared filter selection.
-   * @param {object|boolean} index Boolean flag or options hash for
-   *  a data cube indexer. Falsy values disable indexing.
-   */
-  constructor(coordinator, selection, index = true) {
-    this.mc = coordinator;
-    this.selection = selection;
-    /** @type {Set<MosaicClient>} */
-    this.clients = new Set();
-    /** @type {DataCubeIndexer | null} */
-    this.indexer = null;
-    this.index(index);
-
-    const { value, activate } = this.handlers = {
-      value: () => this.update(),
-      activate: clause => { this.indexer?.index(this.clients, clause); }
-    };
-    selection.addEventListener('value', value);
-    selection.addEventListener('activate', activate);
-  }
-
-  finalize() {
-    const { value, activate } = this.handlers;
-    this.selection.removeEventListener('value', value);
-    this.selection.removeEventListener('activate', activate);
-  }
-
-  index(state) {
-    const { selection } = this;
-    const { resolver } = selection;
-    this.indexer = state && (resolver.single || !resolver.union)
-      ? new DataCubeIndexer(this.mc, { ...state, selection })
-      : null;
-  }
-
-  reset() {
-    this.indexer?.reset();
-  }
-
-  add(client) {
-    (this.clients = new Set(this.clients)).add(client);
-    return this;
-  }
-
-  remove(client) {
-    if (this.clients.has(client)) {
-      (this.clients = new Set(this.clients)).delete(client);
-    }
-    return this;
-  }
-
-  /**
-   * Internal method to process a selection update.
-   * The return value is passed as a selection callback value.
-   * @returns {Promise} A Promise that resolves when the update completes.
-   */
-  update() {
-    const { mc, indexer, clients, selection } = this;
-    const hasIndex = indexer?.index(clients);
-    return hasIndex
-      ? indexer.update()
-      : defaultUpdate(mc, clients, selection);
-  }
-}
-
-function defaultUpdate(mc, clients, selection) {
-  return Promise.all(Array.from(clients).map(client => {
-    const filter = selection.predicate(client);
-    if (filter != null) {
-      return mc.updateClient(client, client.query(filter));
-    }
-  }));
-}