@uwdata/mosaic-core 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-core",
-  "version": "0.4.0",
+  "version": "0.5.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.5.0",
+    "apache-arrow": "^14.0.1"
   },
-  "gitHead": "4114465543a21b25d6d14647db7d95af875d2519"
+  "gitHead": "92886dddfb126c1439924c5a0189e4639c3519a7"
 }

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/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