@uwdata/mosaic-core 0.9.0 → 0.11.0

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

@@ -0,0 +1,60 @@
+import { isArrowTable } from './is-arrow-table.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('@uwdata/flechette').Table} data An Arrow Table.
+ * @returns {DataColumns} An object with named column arrays.
+ */
+function arrowToColumns(data) {
+  const { numRows } = data;
+  return { numRows, columns: data.toColumns() };
+}
+
+/**
+ * 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));
-    }
-  }));
-}

package/src/util/convert-arrow.js

@@ -1,145 +0,0 @@
-import { DataType } from 'apache-arrow';
-
-/**
- * @typedef {import('apache-arrow').Vector} Vector
- */
-
-/**
- * Test if a value is an Apache Arrow table.
- * As sometimes multiple Arrow versions may be used simultaneously,
- * we use a "duck typing" approach and check for a getChild function.
- * @param {*} values The value to test
- * @returns {values is import('apache-arrow').Table} true if the value duck types as Apache Arrow data
- */
-export function isArrowTable(values) {
-  return typeof values?.getChild === 'function';
-}
-
-/**
-  * Return a JavaScript array type for an Apache Arrow column type.
-  * @param {DataType} type an Apache Arrow column type
-  * @returns a JavaScript array constructor
-  */
-export function convertArrowArrayType(type) {
-  return DataType.isInt(type) || DataType.isFloat(type) || DataType.isDecimal(type)
-    ? Float64Array
-    : Array;
-}
-
-/**
- * Return a function that converts Apache Arrow values to JavaScript values.
- * Timestamps are converted to Date values.
- * Large integers (BigInt) are converted to Float64 numbers.
- * Fixed-point decimal values are convert to Float64 numbers.
- * Otherwise, the default Arrow values are used.
- * @param {DataType} type an Apache Arrow column type
- * @returns a value conversion function
- */
-export function convertArrowValue(type) {
-  // map timestamp numbers to date objects
-  if (DataType.isTimestamp(type)) {
-    return v => v == null ? v : new Date(v);
-  }
-
-  // map bigint to number
-  if (DataType.isInt(type) && type.bitWidth >= 64) {
-    return v => v == null ? v : Number(v);
-  }
-
-  // map decimal to number
-  if (DataType.isDecimal(type)) {
-    const scale = 1 / Math.pow(10, type.scale);
-    return v => v == null ? v : decimalToNumber(v, scale);
-  }
-
-  // otherwise use Arrow JS defaults
-  return v => v;
-}
-
-/**
- * Convert an Apache Arrow column to a JavaScript array.
- * Timestamps are converted to Date values.
- * Large integers (BigInt) are converted to Float64 numbers.
- * Fixed-point decimal values are convert to Float64 numbers.
- * Otherwise, the default Arrow values are used.
- * @param {Vector} column An Apache Arrow column
- * @returns an array of values
- */
-export function convertArrowColumn(column) {
-  const { type } = column;
-
-  // map timestamp numbers to date objects
-  if (DataType.isTimestamp(type)) {
-    const size = column.length;
-    const array = new Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v = column.get(row);
-      array[row] = v == null ? null : new Date(v);
-    }
-    return array;
-  }
-
-  // map bigint to number
-  if (DataType.isInt(type) && type.bitWidth >= 64) {
-    const size = column.length;
-    const array = column.nullCount ? new Array(size) : new Float64Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v = column.get(row);
-      array[row] = v == null ? null : Number(v);
-    }
-    return array;
-  }
-
-  // map decimal to number
-  if (DataType.isDecimal(type)) {
-    const scale = 1 / Math.pow(10, type.scale);
-    const size = column.length;
-    const array = column.nullCount ? new Array(size) : new Float64Array(size);
-    for (let row = 0; row < size; ++row) {
-      const v = column.get(row);
-      array[row] = v == null ? null : decimalToNumber(v, scale);
-    }
-    return array;
-  }
-
-  // if there are null values, use a standard array
-  if (column.nullCount) {
-    return Array.from(column);
-  }
-
-  // otherwise use Arrow JS defaults
-  return column.toArray();
-}
-
-// generate base values for big integers
-// represented within a Uint32Array
-const BASE32 = Array.from(
-  { length: 8 },
-  (_, i) => Math.pow(2, i * 32)
-);
-
-/**
- * Convert a fixed point decimal value to a double precision number.
- * Note: if the value is sufficiently large the conversion may be lossy!
- * @param {Uint32Array & { signed: boolean }} v a fixed decimal value
- * @param {number} scale a scale factor, corresponding to the
- *  number of fractional decimal digits in the fixed point value
- * @returns {number} the resulting number
- */
-function decimalToNumber(v, scale) {
-  const n = v.length;
-  let x = 0;
-
-  if (v.signed && (v[n - 1] | 0) < 0) {
-    for (let i = 0; i < n; ++i) {
-      x += ~v[i] * BASE32[i];
-    }
-    x = -(x + 1);
-  } else {
-    for (let i = 0; i < n; ++i) {
-      x += v[i] * BASE32[i];
-    }
-  }
-
-  return x * scale;
-}