@uwdata/mosaic-core 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-core",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Scalable and extensible linked data views.",
   "keywords": [
     "mosaic",
@@ -28,9 +28,9 @@
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
   "dependencies": {
-    "@duckdb/duckdb-wasm": "^1.28.0",
-    "@uwdata/mosaic-sql": "^0.4.0",
-    "apache-arrow": "^13.0.0"
+    "@duckdb/duckdb-wasm": "^1.28.1-dev106.0",
+    "@uwdata/mosaic-sql": "^0.6.0",
+    "apache-arrow": "^14.0.1"
   },
-  "gitHead": "4114465543a21b25d6d14647db7d95af875d2519"
+  "gitHead": "51517b28e916e355f4ce0dc6e98aef3a1db3f7b2"
 }

package/src/Catalog.js

@@ -6,6 +6,7 @@ const object = () => Object.create(null);
 
 export class Catalog {
   constructor(coordinator) {
+    /** @type {import('@uwdata/mosaic-core').Coordinator} */
     this.mc = coordinator;
     this.clear();
   }

package/src/Coordinator.js

@@ -23,9 +23,13 @@ export function coordinator(instance) {
 
 export class Coordinator {
   constructor(db = socketConnector(), options = {}) {
+    const {
+      logger = console,
+      manager = QueryManager()
+    } = options;
     this.catalog = new Catalog(this);
-    this.manager = options.manager || QueryManager();
-    this.logger(options.logger || console);
+    this.manager = manager;
+    this.logger(logger);
     this.configure(options);
     this.databaseConnector(db);
     this.clear();
@@ -68,6 +72,7 @@ export class Coordinator {
   }
 
   exec(query, { priority = Priority.Normal } = {}) {
+    query = Array.isArray(query) ? query.join(';\n') : query;
     return this.manager.request({ type: 'exec', query }, priority);
   }
 
@@ -123,6 +128,7 @@ export class Coordinator {
       throw new Error('Client already connected.');
     }
     clients.add(client); // mark as connected
+    client.coordinator = this;
 
     // retrieve field statistics
     const fields = client.fields();
@@ -154,5 +160,6 @@ export class Coordinator {
     if (!clients.has(client)) return;
     clients.delete(client);
     filterGroups.get(client.filterBy)?.remove(client);
+    client.coordinator = null;
   }
 }

package/src/DataCubeIndexer.js

@@ -1,8 +1,6 @@
-import { Query, and, asColumn, create, epoch_ms, isBetween, sql } from '@uwdata/mosaic-sql';
+import { Query, and, create, isBetween, scaleTransform, sql } from '@uwdata/mosaic-sql';
 import { fnv_hash } from './util/hash.js';
 
-const identity = x => x;
-
 /**
  * Build and query optimized indices ("data cubes") for fast computation of
  * groupby aggregate queries over compatible client queries and selections.
@@ -149,7 +147,7 @@ function getActiveView(clause) {
       );
     }
   } else if (type === 'point') {
-    predicate = identity;
+    predicate = x => x;
     columns = Object.fromEntries(columns.map(col => [col.toString(), col]));
   } else {
     return null; // unsupported type
@@ -159,42 +157,15 @@ function getActiveView(clause) {
 }
 
 function binInterval(scale, pixelSize) {
-  const { type, domain, range } = scale;
-  let lift, toSql;
-
-  switch (type) {
-    case 'linear':
-      lift = identity;
-      toSql = asColumn;
-      break;
-    case 'log':
-      lift = Math.log;
-      toSql = c => sql`LN(${asColumn(c)})`;
-      break;
-    case 'symlog':
-      // TODO: support log constants other than 1?
-      lift = x => Math.sign(x) * Math.log1p(Math.abs(x));
-      toSql = c => (c = asColumn(c), sql`SIGN(${c}) * LN(1 + ABS(${c}))`);
-      break;
-    case 'sqrt':
-      lift = Math.sqrt;
-      toSql = c => sql`SQRT(${asColumn(c)})`;
-      break;
-    case 'utc':
-    case 'time':
-      lift = x => +x;
-      toSql = c => c instanceof Date ? +c : epoch_ms(asColumn(c));
-      break;
+  const { apply, sqlApply } = scaleTransform(scale);
+  if (apply) {
+    const { domain, range } = scale;
+    const lo = apply(Math.min(...domain));
+    const hi = apply(Math.max(...domain));
+    const a = (Math.abs(range[1] - range[0]) / (hi - lo)) / pixelSize;
+    const s = pixelSize === 1 ? '' : `${pixelSize}::INTEGER * `;
+    return value => sql`${s}FLOOR(${a}::DOUBLE * (${sqlApply(value)} - ${lo}::DOUBLE))::INTEGER`;
   }
-  return lift ? binFunction(domain, range, pixelSize, lift, toSql) : null;
-}
-
-function binFunction(domain, range, pixelSize, lift, toSql) {
-  const lo = lift(Math.min(domain[0], domain[1]));
-  const hi = lift(Math.max(domain[0], domain[1]));
-  const a = (Math.abs(lift(range[1]) - lift(range[0])) / (hi - lo)) / pixelSize;
-  const s = pixelSize === 1 ? '' : `${pixelSize}::INTEGER * `;
-  return value => sql`${s}FLOOR(${a}::DOUBLE * (${toSql(value)} - ${lo}::DOUBLE))::INTEGER`;
 }
 
 const NO_INDEX = { from: NaN };

package/src/MosaicClient.js

@@ -1,4 +1,3 @@
-import { coordinator } from './Coordinator.js';
 import { throttle } from './util/throttle.js';
 
 /**
@@ -14,6 +13,21 @@ export class MosaicClient {
   constructor(filterSelection) {
     this._filterBy = filterSelection;
     this._requestUpdate = throttle(() => this.requestQuery(), true);
+    this._coordinator = null;
+  }
+
+  /**
+   * Return this client's connected coordinator.
+   */
+  get coordinator() {
+    return this._coordinator;
+  }
+
+  /**
+   * Set this client's connected coordinator.
+   */
+  set coordinator(coordinator) {
+    this._coordinator = coordinator;
   }
 
   /**
@@ -63,7 +77,7 @@ export class MosaicClient {
 
   /**
    * Called by the coordinator to return a query result.
-   * 
+   *
    * @param {*} data the query result
    * @returns {this}
    */
@@ -86,7 +100,7 @@ export class MosaicClient {
    */
   requestQuery(query) {
     const q = query || this.query(this.filterBy?.predicate(this));
-    return coordinator().requestQuery(this, q);
+    return this._coordinator.requestQuery(this, q);
   }
 
   /**

package/src/QueryConsolidator.js

@@ -1,6 +1,13 @@
 import { Query, Ref } from '@uwdata/mosaic-sql';
 import { queryResult } from './util/query-result.js';
 
+function wait(callback) {
+  const method = typeof requestAnimationFrame !== 'undefined'
+    ? requestAnimationFrame
+    : typeof setImmediate !== 'undefined' ? setImmediate : setTimeout;
+  return method(callback);
+}
+
 /**
  * Create a consolidator to combine structurally compatible queries.
  * @param {*} enqueue Query manager enqueue method
@@ -30,7 +37,7 @@ export function consolidator(enqueue, cache, record) {
       if (entry.request.type === 'arrow') {
         // wait one frame, gather an ordered list of queries
         // only Apache Arrow is supported, so we can project efficiently
-        id = id || requestAnimationFrame(() => run());
+        id = id || wait(() => run());
         pending.push({ entry, priority, index: pending.length });
       } else {
         enqueue(entry, priority);

package/src/connectors/wasm.js

@@ -1,14 +1,57 @@
 import * as duckdb from '@duckdb/duckdb-wasm';
 
-export async function wasmConnector(options) {
-  const db = await initDatabase(options);
-  const con = await db.connect();
+export function wasmConnector(options = {}) {
+  const { duckdb, connection, ...opts } = options;
+  let db = duckdb;
+  let con = connection;
+  let loadPromise;
+
+  function load() {
+    if (!loadPromise) {
+      // use a loading promise to avoid race conditions
+      // synchronizes multiple callees on the same load
+      loadPromise = (db
+        ? Promise.resolve(db)
+        : initDatabase(opts).then(result => db = result))
+        .then(db => db.connect())
+        .then(result => con = result);
+    }
+    return loadPromise;
+  }
+
+  /**
+   * Get the backing DuckDB-WASM instance.
+   * Will lazily initialize DuckDB-WASM if not already loaded.
+   * @returns {duckdb.AsyncDuckDB} The DuckDB-WASM instance.
+   */
+  async function getDuckDB() {
+    if (!db) await load();
+    return db;
+  }
+
+  /**
+   * Get the backing DuckDB-WASM connection.
+   * Will lazily initialize DuckDB-WASM if not already loaded.
+   * @returns {duckdb.AsyncDuckDBConnection} The DuckDB-WASM connection.
+   */
+  async function getConnection() {
+    if (!con) await load();
+    return con;
+  }
 
   return {
-    db,
-    con,
+    getDuckDB,
+    getConnection,
+    /**
+     * Query the DuckDB-WASM instance.
+     * @param {object} query
+     * @param {string} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {string} query.sql A SQL query string.
+     * @returns the query result
+     */
     query: async query => {
       const { type, sql } = query;
+      const con = await getConnection();
       const result = await con.query(sql);
       return type === 'exec' ? undefined
         : type === 'arrow' ? result