@uwdata/mosaic-core 0.10.0 → 0.12.0

package/src/QueryConsolidator.js

@@ -1,4 +1,4 @@
-import { Query, Ref, isDescribeQuery } from '@uwdata/mosaic-sql';
+import { DescribeQuery, isAggregateExpression, isColumnRef, isDescribeQuery, isSelectQuery, Query } from '@uwdata/mosaic-sql';
 import { QueryResult } from './util/query-result.js';
 
 function wait(callback) {
@@ -13,10 +13,9 @@ function wait(callback) {
  * Create a consolidator to combine structurally compatible queries.
  * @param {*} enqueue Query manager enqueue method
  * @param {*} cache Client-side query cache (sql -> data)
- * @param {*} record Query recorder function
  * @returns A consolidator object
  */
-export function consolidator(enqueue, cache, record) {
+export function consolidator(enqueue, cache) {
   let pending = [];
   let id = 0;
 
@@ -28,7 +27,7 @@ export function consolidator(enqueue, cache, record) {
 
     // build and issue consolidated queries
     for (const group of groups) {
-      consolidate(group, enqueue, record);
+      consolidate(group, enqueue);
       processResults(group, cache);
     }
   }
@@ -75,18 +74,16 @@ function entryGroups(entries, cache) {
  * Queries with matching keys are conosolidation-compatible.
  * If a query is found in the cache, it is exempted from consolidation,
  * which is indicated by returning the precise query SQL as the key.
- * @param {*} query The input query.
+ * @param {Query | DescribeQuery} query The input query.
  * @param {*} cache The query cache (sql -> data).
  * @returns a key string
  */
 function consolidationKey(query, cache) {
   const sql = `${query}`;
-  if (query instanceof Query && !cache.get(sql)) {
+  if (isSelectQuery(query) && !cache.get(sql)) {
     if (
-      // @ts-ignore
-      query.orderby().length || query.where().length ||
-      // @ts-ignore
-      query.qualify().length || query.having().length
+      query._orderby.length || query._where.length ||
+      query._qualify.length || query._having.length
     ) {
       // do not try to analyze if query includes clauses
       // that may refer to *derived* columns we can't resolve
@@ -94,19 +91,21 @@ function consolidationKey(query, cache) {
     }
 
     // create a derived query stripped of selections
-    const q = query.clone().$select('*');
+    const q = query.clone().setSelect('*');
 
     // check group by criteria for compatibility
     // queries may refer to *derived* columns as group by criteria
     // we resolve these against the true grouping expressions
-    const groupby = query.groupby();
-    // @ts-ignore
+    const groupby = query._groupby;
     if (groupby.length) {
-      const map = {}; // expression map (as -> expr)
-      // @ts-ignore
-      query.select().forEach(({ as, expr }) => map[as] = expr);
-      // @ts-ignore
-      q.$groupby(groupby.map(e => (e instanceof Ref && map[e.column]) || e));
+      const map = {}; // expression map (alias -> expr)
+      query._select.forEach(({ alias, expr }) => map[alias] = expr);
+      q.setGroupby(groupby.map(e => (isColumnRef(e) && map[e.column]) || e));
+    }
+    else if (query._select.some(e => isAggregateExpression(e.expr))) {
+      // if query is an ungrouped aggregate, add an explicit groupby to
+      // prevent improper consolidation with non-aggregate queries
+      q.setGroupby('ALL');
     }
 
     // key is just the transformed query as SQL
@@ -121,17 +120,15 @@ function consolidationKey(query, cache) {
  * Issue queries, consolidating where possible.
  * @param {*} group Array of bundled query entries
  * @param {*} enqueue Add entry to query queue
- * @param {*} record Query recorder function
  */
-function consolidate(group, enqueue, record) {
+function consolidate(group, enqueue) {
   if (shouldConsolidate(group)) {
     // issue a single consolidated query
     enqueue({
       request: {
         type: 'arrow',
         cache: false,
-        record: false,
-        query: (group.query = consolidatedQuery(group, record))
+        query: (group.query = consolidatedQuery(group))
       },
       result: (group.result = new QueryResult())
     });
@@ -164,10 +161,9 @@ function shouldConsolidate(group) {
 /**
  * Create a consolidated query for a group.
  * @param {*} group Array of bundled query entries
- * @param {*} record Query recorder function
  * @returns A consolidated Query instance
  */
-function consolidatedQuery(group, record) {
+function consolidatedQuery(group) {
   const maps = group.maps = [];
   const fields = new Map;
 
@@ -176,30 +172,29 @@ function consolidatedQuery(group, record) {
     const { query } = item.entry.request;
     const fieldMap = [];
     maps.push(fieldMap);
-    for (const { as, expr } of query.select()) {
+    for (const { alias, expr } of query._select) {
       const e = `${expr}`;
       if (!fields.has(e)) {
         fields.set(e, [`col${fields.size}`, expr]);
       }
       const [name] = fields.get(e);
-      fieldMap.push([name, as]);
+      fieldMap.push([name, alias]);
     }
-    record(`${query}`);
   }
 
   // use a cloned query as a starting point
   const query = group[0].entry.request.query.clone();
 
   // update group by statement as needed
-  const groupby = query.groupby();
+  const groupby = query._groupby;
   if (groupby.length) {
     const map = {};
     group.maps[0].forEach(([name, as]) => map[as] = name);
-    query.$groupby(groupby.map(e => (e instanceof Ref && map[e.column]) || e));
+    query.setGroupby(groupby.map(e => (isColumnRef(e) && map[e.column]) || e));
   }
 
   // update select statement and return
-  return query.$select(Array.from(fields.values()));
+  return query.setSelect(Array.from(fields.values()));
 }
 
 /**
@@ -244,22 +239,20 @@ async function processResults(group, cache) {
 
 /**
  * Project a consolidated result to a client result
- * @param {*} data Consolidated query result, as an Apache Arrow Table
- * @param {*} map Column name map as [source, target] pairs
+ * @param {import('@uwdata/flechette').Table} data
+ *  Consolidated query result, as an Arrow Table
+ * @param {[string, string][]} map Column name map as [source, target] pairs
  * @returns the projected Apache Arrow table
  */
 function projectResult(data, map) {
-  const cols = {};
-  for (const [name, as] of map) {
-    cols[as] = data.getChild(name);
-  }
-  return new data.constructor(cols);
+  return data.select(map.map(x => x[0]), map.map(x => x[1]));
 }
 
 /**
  * Filter a consolidated describe query result to a client result
- * @param {*} data Consolidated query result
- * @param {*} map Column name map as [source, target] pairs
+ * @param {import('@uwdata/flechette').Table} data
+ *  Consolidated query result, as an Arrow Table
+ * @param {[string, string][]} map Column name map as [source, target] pairs
  * @returns the filtered table data
  */
 function filterResult(data, map) {

package/src/QueryManager.js

@@ -1,56 +1,85 @@
 import { consolidator } from './QueryConsolidator.js';
 import { lruCache, voidCache } from './util/cache.js';
-import { priorityQueue } from './util/priority-queue.js';
-import { QueryResult } from './util/query-result.js';
+import { PriorityQueue } from './util/priority-queue.js';
+import { QueryResult, QueryState } from './util/query-result.js';
+import { voidLogger } from './util/void-logger.js';
 
-export const Priority = { High: 0, Normal: 1, Low: 2 };
+export const Priority = Object.freeze({ High: 0, Normal: 1, Low: 2 });
 
 export class QueryManager {
-  constructor() {
-    this.queue = priorityQueue(3);
+  constructor(
+    maxConcurrentRequests = 32
+  ) {
+    this.queue = new PriorityQueue(3);
     this.db = null;
     this.clientCache = null;
-    this._logger = null;
+    this._logger = voidLogger();
     this._logQueries = false;
-    this.recorders = [];
-    this.pending = null;
     this._consolidate = null;
+    /**
+     * Requests pending with the query manager.
+     * 
+     * @type {QueryResult[]}
+     */
+    this.pendingResults = [];
+    this.maxConcurrentRequests = maxConcurrentRequests;
+    this.pendingExec = false;
   }
 
   next() {
-    if (this.pending || this.queue.isEmpty()) return;
+    if (this.queue.isEmpty() || this.pendingResults.length > this.maxConcurrentRequests || this.pendingExec) {
+      return;
+    }
+
     const { request, result } = this.queue.next();
-    this.pending = this.submit(request, result);
-    this.pending.finally(() => { this.pending = null; this.next(); });
+
+    this.pendingResults.push(result);
+    if (request.type === 'exec') this.pendingExec = true;
+
+    this.submit(request, result).finally(() => {
+      // return from the queue all requests that are ready
+      while (this.pendingResults.length && this.pendingResults[0].state !== QueryState.pending) {
+        const result = this.pendingResults.shift();
+        if (result.state === QueryState.ready) {
+          result.fulfill();
+        } else if (result.state === QueryState.done) {
+          this._logger.warn('Found resolved query in pending results.');
+        }
+      }
+      if (request.type === 'exec') this.pendingExec = false;
+      this.next();
+    });
   }
 
+  /**
+   * Add an entry to the query queue with a priority.
+   * @param {object} entry The entry to add.
+   * @param {*} [entry.request] The query request.
+   * @param {QueryResult} [entry.result] The query result.
+   * @param {number} priority The query priority, defaults to `Priority.Normal`.
+   */
   enqueue(entry, priority = Priority.Normal) {
     this.queue.insert(entry, priority);
     this.next();
   }
 
-  recordQuery(sql) {
-    if (this.recorders.length && sql) {
-      this.recorders.forEach(rec => rec.add(sql));
-    }
-  }
-
+  /**
+   * Submit the query to the connector.
+   * @param {*} request The request.
+   * @param {QueryResult} result The query result.
+   */
   async submit(request, result) {
     try {
-      const { query, type, cache = false, record = true, options } = request;
+      const { query, type, cache = false, options } = request;
       const sql = query ? `${query}` : null;
 
-      // update recorders
-      if (record) {
-        this.recordQuery(sql);
-      }
-
       // check query cache
       if (cache) {
         const cached = this.clientCache.get(sql);
         if (cached) {
+          const data = await cached;
           this._logger.debug('Cache');
-          result.fulfill(cached);
+          result.ready(data);
           return;
         }
       }
@@ -60,10 +89,16 @@ export class QueryManager {
       if (this._logQueries) {
         this._logger.debug('Query', { type, sql, ...options });
       }
-      const data = await this.db.query({ type, sql, ...options });
+
+      const promise = this.db.query({ type, sql, ...options });
+      if (cache) this.clientCache.set(sql, promise);
+
+      const data = await promise;
+
       if (cache) this.clientCache.set(sql, data);
+
       this._logger.debug(`Request: ${(performance.now() - t0).toFixed(1)}`);
-      result.fulfill(data);
+      result.ready(type === 'exec' ? null : data);
     } catch (err) {
       result.reject(err);
     }
@@ -89,12 +124,18 @@ export class QueryManager {
 
   consolidate(flag) {
     if (flag && !this._consolidate) {
-      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache, this.recordQuery.bind(this));
+      this._consolidate = consolidator(this.enqueue.bind(this), this.clientCache);
     } else if (!flag && this._consolidate) {
       this._consolidate = null;
     }
   }
 
+  /**
+   * Request a query result.
+   * @param {*} request The request.
+   * @param {number} priority The query priority, defaults to `Priority.Normal`.
+   * @returns {QueryResult} A query result promise.
+   */
   request(request, priority = Priority.Normal) {
     const result = new QueryResult();
     const entry = { request, result };
@@ -109,7 +150,19 @@ export class QueryManager {
   cancel(requests) {
     const set = new Set(requests);
     if (set.size) {
-      this.queue.remove(({ result }) => set.has(result));
+      this.queue.remove(({ result }) => {
+        if (set.has(result)) {
+          result.reject('Canceled');
+          return true;
+        }
+        return false;
+      });
+
+      for (const result of this.pendingResults) {
+        if (set.has(result)) {
+          result.reject('Canceled');
+        }
+      }
     }
   }
 
@@ -118,26 +171,10 @@ export class QueryManager {
       result.reject('Cleared');
       return true;
     });
-  }
 
-  record() {
-    let state = [];
-    const recorder = {
-      add(query) {
-        state.push(query);
-      },
-      reset() {
-        state = [];
-      },
-      snapshot() {
-        return state.slice();
-      },
-      stop() {
-        this.recorders = this.recorders.filter(x => x !== recorder);
-        return state;
-      }
-    };
-    this.recorders.push(recorder);
-    return recorder;
+    for (const result of this.pendingResults) {
+      result.reject('Cleared');
+    }
+    this.pendingResults = [];
   }
 }

package/src/Selection.js

@@ -1,5 +1,6 @@
-import { or } from '@uwdata/mosaic-sql';
+import { literal, or } from '@uwdata/mosaic-sql';
 import { Param } from './Param.js';
+import { MosaicClient } from './MosaicClient.js';
 
 /**
  * Test if a value is a Selection instance.
@@ -10,6 +11,13 @@ export function isSelection(x) {
   return x instanceof Selection;
 }
 
+function create(options, include) {
+  return new Selection(
+    new SelectionResolver(options),
+    include ? [include].flat() : include
+  );
+}
+
 /**
  * Represents a dynamic set of query filter predicates.
  */
@@ -25,10 +33,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static intersect({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty }));
+  static intersect({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty }, include);
   }
 
   /**
@@ -41,10 +52,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static union({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty, union: true }));
+  static union({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty, union: true }, include);
   }
 
   /**
@@ -57,10 +71,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static single({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty, single: true }));
+  static single({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty, single: true }, include);
   }
 
   /**
@@ -70,21 +87,34 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static crossfilter({ empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross: true, empty }));
+  static crossfilter({ empty = false, include = [] } = {}) {
+    return create({ cross: true, empty }, include);
   }
 
   /**
    * Create a new Selection instance.
-   * @param {SelectionResolver} resolver The selection resolution
+   * @param {SelectionResolver} [resolver] The selection resolution
    *  strategy to apply.
+   * @param {Selection[]} [include] Upstream selections whose clauses
+   * should be included as part of this selection. Any clauses published
+   * to these upstream selections will be relayed to this selection.
    */
-  constructor(resolver = new SelectionResolver()) {
+  constructor(resolver = new SelectionResolver(), include = []) {
     super([]);
     this._resolved = this._value;
     this._resolver = resolver;
+    /** @type {Set<Selection>} */
+    this._relay = new Set;
+    if (Array.isArray(include)) {
+      for (const sel of include) {
+        sel._relay.add(this);
+      }
+    }
   }
 
   /**
@@ -161,6 +191,7 @@ export class Selection extends Param {
    */
   activate(clause) {
     this.emit('activate', clause);
+    this._relay.forEach(sel => sel.activate(clause));
   }
 
   /**
@@ -173,6 +204,7 @@ export class Selection extends Param {
     // this ensures consistent clause state across unemitted event values
     this._resolved = this._resolver.resolve(this._resolved, clause, true);
     this._resolved.active = clause;
+    this._relay.forEach(sel => sel.update(clause));
     return super.update(this._resolved);
   }
 
@@ -284,9 +316,11 @@ export class SelectionResolver {
 
   /**
    * Return a selection query predicate for the given client.
-   * @param {*[]} clauseList An array of selection clauses.
-   * @param {*} active The current active selection clause.
-   * @param {*} client The client whose data may be filtered.
+   * @param {import('./util/selection-types.js').SelectionClause[]} clauseList
+   *  An array of selection clauses.
+   * @param {import('./util/selection-types.js').SelectionClause} active
+   *  The current active selection clause.
+   * @param {MosaicClient} client The client whose data may be filtered.
    * @returns {*} The query predicate for filtering client data,
    *  based on the current state of this selection.
    */
@@ -294,7 +328,7 @@ export class SelectionResolver {
     const { empty, union } = this;
 
     if (empty && !clauseList.length) {
-      return ['FALSE'];
+      return [literal(false)];
     }
 
     // do nothing if cross-filtering and client is currently active

package/src/SelectionClause.js

@@ -1,7 +1,4 @@
-import {
-  SQLExpression, and, contains, isBetween, isNotDistinct, literal,
-  or, prefix, regexp_matches, suffix
-} from '@uwdata/mosaic-sql';
+import { ExprNode, and, contains, isBetween, isIn, isNotDistinct, literal, or, prefix, regexp_matches, suffix } from '@uwdata/mosaic-sql';
 import { MosaicClient } from './MosaicClient.js';
 
 /**
@@ -10,12 +7,11 @@ import { MosaicClient } from './MosaicClient.js';
  * @typedef {import('./util/selection-types.js').Extent} Extent
  * @typedef {import('./util/selection-types.js').MatchMethod} MatchMethod
  * @typedef {import('./util/selection-types.js').BinMethod} BinMethod
- * @typedef {SQLExpression | string} Field
  */
 
 /**
  * Generate a selection clause for a single selected point value.
- * @param {Field} field The table column or expression to select.
+ * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
  * @param {*} value The selected value.
  * @param {object} options Additional clause properties.
  * @param {*} options.source The source component generating this clause.
@@ -28,7 +24,7 @@ export function clausePoint(field, value, {
   source,
   clients = source ? new Set([source]) : undefined
 }) {
-  /** @type {SQLExpression | null} */
+  /** @type {ExprNode | null} */
   const predicate = value !== undefined
     ? isNotDistinct(field, literal(value))
     : null;
@@ -43,9 +39,9 @@ export function clausePoint(field, value, {
 
 /**
  * Generate a selection clause for multiple selected point values.
- * @param {Field[]} fields The table columns or expressions to select.
- * @param {any[][]} value The selected values, as an array of arrays where
- *  each subarray contains values corresponding to each *fields* entry.
+ * @param {import('@uwdata/mosaic-sql').ExprValue[]} fields The table columns or expressions to select.
+ * @param {any[][] | undefined} value The selected values, as an array of
+ *  arrays. Each subarray contains values for each *fields* entry.
  * @param {object} options Additional clause properties.
  * @param {*} options.source The source component generating this clause.
  * @param {Set<MosaicClient>} [options.clients] The Mosaic clients associated
@@ -57,14 +53,15 @@ export function clausePoints(fields, value, {
   source,
   clients = source ? new Set([source]) : undefined
 }) {
-  /** @type {SQLExpression | null} */
+  /** @type {ExprNode | null} */
   let predicate = null;
   if (value) {
-    const clauses = value.map(vals => {
-      const list = vals.map((v, i) => isNotDistinct(fields[i], literal(v)));
-      return list.length > 1 ? and(list) : list[0];
-    });
-    predicate = clauses.length > 1 ? or(clauses) : clauses[0];
+    const clauses = value.length && fields.length === 1
+      ? [isIn(fields[0], value.map(v => literal(v[0])))]
+      : value.map(v => and(v.map((_, i) => isNotDistinct(fields[i], literal(_)))));
+    predicate = value.length === 0 ? literal(false)
+      : clauses.length > 1 ? or(clauses)
+      : clauses[0];
   }
   return {
     meta: { type: 'point' },
@@ -77,7 +74,7 @@ export function clausePoints(fields, value, {
 
 /**
  * Generate a selection clause for a selected 1D interval.
- * @param {Field} field The table column or expression to select.
+ * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
  * @param {Extent} value The selected interval as a [lo, hi] array.
  * @param {object} options Additional clause properties.
  * @param {*} options.source The source component generating this clause.
@@ -96,7 +93,7 @@ export function clauseInterval(field, value, {
   scale,
   pixelSize = 1
 }) {
-  /** @type {SQLExpression | null} */
+  /** @type {ExprNode | null} */
   const predicate = value != null ? isBetween(field, value) : null;
   /** @type {import('./util/selection-types.js').IntervalMetadata} */
   const meta = { type: 'interval', scales: scale && [scale], bin, pixelSize };
@@ -105,7 +102,7 @@ export function clauseInterval(field, value, {
 
 /**
  * Generate a selection clause for multiple selected intervals.
- * @param {Field[]} fields The table columns or expressions to select.
+ * @param {import('@uwdata/mosaic-sql').ExprValue[]} fields The table columns or expressions to select.
  * @param {Extent[]} value The selected intervals, as an array of extents.
  * @param {object} options Additional clause properties.
  * @param {*} options.source The source component generating this clause.
@@ -125,7 +122,7 @@ export function clauseIntervals(fields, value, {
   scales = [],
   pixelSize = 1
 }) {
-  /** @type {SQLExpression | null} */
+  /** @type {ExprNode | null} */
   const predicate = value != null
     ? and(fields.map((f, i) => isBetween(f, value[i])))
     : null;
@@ -138,7 +135,7 @@ const MATCH_METHODS = { contains, prefix, suffix, regexp: regexp_matches };
 
 /**
  * Generate a selection clause for text search matching.
- * @param {Field} field The table column or expression to select.
+ * @param {import('@uwdata/mosaic-sql').ExprValue} field The table column or expression to select.
  * @param {string} value The selected text search query string.
  * @param {object} options Additional clause properties.
  * @param {*} options.source The source component generating this clause.
@@ -153,7 +150,7 @@ export function clauseMatch(field, value, {
   source, clients = undefined, method = 'contains'
 }) {
   let fn = MATCH_METHODS[method];
-  /** @type {SQLExpression | null} */
+  /** @type {ExprNode | null} */
   const predicate = value ? fn(field, literal(value)) : null;
   /** @type {import('./util/selection-types.js').MatchMetadata} */
   const meta = { type: 'match', method };

package/src/connectors/rest.js

@@ -1,12 +1,14 @@
-import { tableFromIPC } from 'apache-arrow';
+import { decodeIPC } from '../util/decode-ipc.js';
 
 export function restConnector(uri = 'http://localhost:3000/') {
   return {
     /**
      * Query the DuckDB server.
      * @param {object} query
-     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
-     * @param {string} query.sql A SQL query string.
+     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
+     * @param {string} [query.sql] A SQL query string.
+     * @param {string[]} [query.queries] The queries used to create a bundle.
+     * @param {string} [query.name] The name of a bundle to create or load.
      * @returns the query result
      */
     async query(query) {
@@ -20,7 +22,7 @@ export function restConnector(uri = 'http://localhost:3000/') {
       });
 
       return query.type === 'exec' ? req
-        : query.type === 'arrow' ? tableFromIPC(req)
+        : query.type === 'arrow' ? decodeIPC(await (await req).arrayBuffer())
         : (await req).json();
     }
   };