@uwdata/mosaic-inputs 0.6.1 → 0.7.0

package/LICENSE

@@ -26,3 +26,22 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+Portions of this software are derived from Observable Plot, which is released
+under the ISC license.
+
+Copyright 2020-2023 Observable, Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/dist/mosaic-inputs.js

@@ -12365,6 +12365,15 @@ var Query = class _Query {
   static except(...queries) {
     return new SetOperation("EXCEPT", queries.flat());
   }
+  static describe(query) {
+    const q = query.clone();
+    const { clone, toString } = q;
+    return Object.assign(q, {
+      describe: true,
+      clone: () => _Query.describe(clone.call(q)),
+      toString: () => `DESCRIBE ${toString.call(q)}`
+    });
+  }
   constructor() {
     this.query = {
       with: [],
@@ -12599,6 +12608,7 @@ var Query = class _Query {
   }
   toString() {
     const {
+      with: cte,
       select,
       distinct: distinct2,
       from,
@@ -12610,8 +12620,7 @@ var Query = class _Query {
       qualify,
       orderby,
       limit,
-      offset,
-      with: cte
+      offset
     } = this.query;
     const sql2 = [];
     if (cte.length) {
@@ -12733,6 +12742,9 @@ var SetOperation = class _SetOperation {
 function isQuery(value) {
   return value instanceof Query || value instanceof SetOperation;
 }
+function isDescribeQuery(value) {
+  return isQuery(value) && value.describe;
+}
 function unquote(s) {
   return isDoubleQuoted(s) ? s.slice(1, -1) : s;
 }
@@ -12832,131 +12844,6 @@ function create(name, query, {
   return "CREATE" + (replace ? " OR REPLACE " : " ") + (temp ? "TEMP " : "") + (view ? "VIEW" : "TABLE") + (replace ? " " : " IF NOT EXISTS ") + name + " AS " + query;
 }
 
-// ../core/src/util/js-type.js
-function jsType(type) {
-  switch (type) {
-    case "BIGINT":
-    case "HUGEINT":
-    case "INTEGER":
-    case "SMALLINT":
-    case "TINYINT":
-    case "UBIGINT":
-    case "UINTEGER":
-    case "USMALLINT":
-    case "UTINYINT":
-    case "DOUBLE":
-    case "FLOAT":
-    case "REAL":
-    case "DECIMAL":
-      return "number";
-    case "DATE":
-    case "TIMESTAMP":
-    case "TIMESTAMPTZ":
-    case "TIMESTAMP WITH TIME ZONE":
-    case "TIME":
-    case "TIMESTAMP_NS":
-      return "date";
-    case "BOOLEAN":
-      return "boolean";
-    case "VARCHAR":
-    case "UUID":
-      return "string";
-    case "LIST":
-      return "array";
-    case "BLOB":
-    case "STRUCT":
-    case "MAP":
-      return "object";
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
-}
-
-// ../core/src/util/summarize.js
-var Count = "count";
-var Nulls = "nulls";
-var Max = "max";
-var Min = "min";
-var Distinct = "distinct";
-var statMap = {
-  [Count]: count,
-  [Distinct]: (column2) => count(column2).distinct(),
-  [Max]: max,
-  [Min]: min,
-  [Nulls]: (column2) => count().where(isNull(column2))
-};
-function summarize({ table: table2, column: column2 }, stats) {
-  return Query.from(table2).select(stats.map((s) => [s, statMap[s](column2)]));
-}
-
-// ../core/src/Catalog.js
-var object = () => /* @__PURE__ */ Object.create(null);
-var Catalog = class {
-  constructor(coordinator2) {
-    this.mc = coordinator2;
-    this.clear();
-  }
-  clear() {
-    this.tables = object();
-  }
-  tableInfo(table2) {
-    const cache = this.tables;
-    if (cache[table2]) {
-      return cache[table2];
-    }
-    const infoPromise = getTableInfo(this.mc, table2).catch((err) => {
-      cache[table2] = null;
-      throw err;
-    });
-    return cache[table2] = infoPromise;
-  }
-  async fieldInfo({ table: table2, column: column2, stats }) {
-    const tableInfo = await this.tableInfo(table2);
-    const colInfo = tableInfo[column2];
-    if (colInfo == null)
-      return;
-    if (!stats?.length)
-      return colInfo;
-    const result = await this.mc.query(
-      summarize(colInfo, stats),
-      { persist: true }
-    );
-    const info = { ...colInfo, ...Array.from(result)[0] };
-    for (const key in info) {
-      const value = info[key];
-      if (typeof value === "bigint") {
-        info[key] = Number(value);
-      }
-    }
-    return info;
-  }
-  async queryFields(fields) {
-    const list = await resolveFields(this, fields);
-    const data = await Promise.all(list.map((f) => this.fieldInfo(f)));
-    return data.filter((x2) => x2);
-  }
-};
-async function getTableInfo(mc, table2) {
-  const result = await mc.query(
-    `DESCRIBE ${asRelation(table2)}`,
-    { type: "json", cache: false }
-  );
-  const columns = object();
-  for (const entry of result) {
-    columns[entry.column_name] = {
-      table: table2,
-      column: entry.column_name,
-      sqlType: entry.column_type,
-      type: jsType(entry.column_type),
-      nullable: entry.null === "YES"
-    };
-  }
-  return columns;
-}
-async function resolveFields(catalog, list) {
-  return list.length === 1 && list[0].column === "*" ? Object.values(await catalog.tableInfo(list[0].table)) : list;
-}
-
 // ../core/src/util/hash.js
 function fnv_hash(v) {
   let a = 2166136261;
@@ -13316,7 +13203,7 @@ function consolidate(group, enqueue, record) {
         type: "arrow",
         cache: false,
         record: false,
-        query: consolidatedQuery(group, record)
+        query: group.query = consolidatedQuery(group, record)
       },
       result: group.result = queryResult()
     });
@@ -13364,7 +13251,7 @@ function consolidatedQuery(group, record) {
   return query.$select(Array.from(fields.values()));
 }
 async function processResults(group, cache) {
-  const { maps, result } = group;
+  const { maps, query, result } = group;
   if (!maps)
     return;
   let data;
@@ -13376,25 +13263,33 @@ async function processResults(group, cache) {
     }
     return;
   }
+  const describe = isDescribeQuery(query);
   group.forEach(({ entry }, index) => {
     const { request, result: result2 } = entry;
-    const projected = projectResult(data, maps[index]);
+    const map = maps[index];
+    const extract = describe && map ? filterResult(data, map) : map ? projectResult(data, map) : data;
     if (request.cache) {
-      cache.set(String(request.query), projected);
+      cache.set(String(request.query), extract);
     }
-    result2.fulfill(projected);
+    result2.fulfill(extract);
   });
 }
 function projectResult(data, map) {
-  if (map) {
-    const cols = {};
-    for (const [name, as] of map) {
-      cols[as] = data.getChild(name);
+  const cols = {};
+  for (const [name, as] of map) {
+    cols[as] = data.getChild(name);
+  }
+  return new data.constructor(cols);
+}
+function filterResult(data, map) {
+  const lookup = new Map(map);
+  const result = [];
+  for (const d of data) {
+    if (lookup.has(d.column_name)) {
+      result.push({ ...d, column_name: lookup.get(d.column_name) });
     }
-    return new data.constructor(cols);
-  } else {
-    return data;
   }
+  return result;
 }
 
 // ../core/src/util/cache.js
@@ -13641,6 +13536,150 @@ function QueryManager() {
   };
 }
 
+// ../core/src/util/js-type.js
+function jsType(type) {
+  switch (type) {
+    case "BIGINT":
+    case "HUGEINT":
+    case "INTEGER":
+    case "SMALLINT":
+    case "TINYINT":
+    case "UBIGINT":
+    case "UINTEGER":
+    case "USMALLINT":
+    case "UTINYINT":
+    case "DOUBLE":
+    case "FLOAT":
+    case "REAL":
+      return "number";
+    case "DATE":
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+    case "TIME":
+    case "TIMESTAMP_NS":
+      return "date";
+    case "BOOLEAN":
+      return "boolean";
+    case "VARCHAR":
+    case "UUID":
+      return "string";
+    case "ARRAY":
+    case "LIST":
+      return "array";
+    case "BLOB":
+    case "STRUCT":
+    case "MAP":
+    case "GEOMETRY":
+      return "object";
+    default:
+      if (type.startsWith("DECIMAL")) {
+        return "number";
+      } else if (type.startsWith("STRUCT") || type.startsWith("MAP")) {
+        return "object";
+      } else if (type.endsWith("]")) {
+        return "array";
+      }
+      throw new Error(`Unsupported type: ${type}`);
+  }
+}
+
+// ../core/src/util/convert-arrow.js
+var INTEGER = 2;
+var DECIMAL = 7;
+var TIMESTAMP = 10;
+function convertArrowValue(type) {
+  const { typeId } = type;
+  if (typeId === TIMESTAMP) {
+    return (v) => v == null ? v : new Date(v);
+  }
+  if (typeId === INTEGER && type.bitWidth >= 64) {
+    return (v) => v == null ? v : Number(v);
+  }
+  if (typeId === DECIMAL) {
+    const scale = 1 / Math.pow(10, type.scale);
+    return (v) => v == null ? v : decimalToNumber(v, scale);
+  }
+  return (v) => v;
+}
+var BASE32 = Array.from(
+  { length: 8 },
+  (_, i) => Math.pow(2, i * 32)
+);
+function decimalToNumber(v, scale) {
+  const n = v.length;
+  let x2 = 0;
+  if (v.signed && (v[n - 1] | 0) < 0) {
+    for (let i = 0; i < n; ++i) {
+      x2 += ~(v[i] | 0) * BASE32[i];
+    }
+    x2 = -(x2 + 1);
+  } else {
+    for (let i = 0; i < n; ++i) {
+      x2 += v[i] * BASE32[i];
+    }
+  }
+  return x2 * scale;
+}
+
+// ../core/src/util/field-info.js
+var Count = "count";
+var Nulls = "nulls";
+var Max = "max";
+var Min = "min";
+var Distinct = "distinct";
+var statMap = {
+  [Count]: count,
+  [Distinct]: (column2) => count(column2).distinct(),
+  [Max]: max,
+  [Min]: min,
+  [Nulls]: (column2) => count().where(isNull(column2))
+};
+function summarize(table2, column2, stats) {
+  return Query.from(table2).select(Array.from(stats, (s) => [s, statMap[s](column2)]));
+}
+async function queryFieldInfo(mc, fields) {
+  if (fields.length === 1 && `${fields[0].column}` === "*") {
+    return getTableInfo(mc, fields[0].table);
+  } else {
+    return (await Promise.all(fields.map((f) => getFieldInfo(mc, f)))).filter((x2) => x2);
+  }
+}
+async function getFieldInfo(mc, { table: table2, column: column2, stats }) {
+  const q = Query.from({ source: table2 }).select({ column: column2 }).groupby(column2.aggregate ? sql`ALL` : []);
+  const [desc2] = Array.from(await mc.query(Query.describe(q)));
+  const info = {
+    table: table2,
+    column: `${column2}`,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  };
+  if (!(stats?.length || stats?.size))
+    return info;
+  const result = await mc.query(
+    summarize(table2, column2, stats),
+    { persist: true }
+  );
+  for (let i = 0; i < result.numCols; ++i) {
+    const { name } = result.schema.fields[i];
+    const child = result.getChildAt(i);
+    const convert = convertArrowValue(child.type);
+    info[name] = convert(child.get(0));
+  }
+  return info;
+}
+async function getTableInfo(mc, table2) {
+  const result = await mc.query(`DESCRIBE ${asRelation(table2)}`);
+  return Array.from(result).map((desc2) => ({
+    table: table2,
+    column: desc2.column_name,
+    sqlType: desc2.column_type,
+    type: jsType(desc2.column_type),
+    nullable: desc2.null === "YES"
+  }));
+}
+
 // ../core/src/util/void-logger.js
 function voidLogger() {
   return {
@@ -13673,7 +13712,6 @@ var Coordinator = class {
       logger = console,
       manager = QueryManager()
     } = options;
-    this.catalog = new Catalog(this);
     this.manager = manager;
     this.logger(logger);
     this.configure(options);
@@ -13692,7 +13730,7 @@ var Coordinator = class {
     this.manager.consolidate(consolidate2);
     this.indexes = indexes;
   }
-  clear({ clients = true, cache = true, catalog = false } = {}) {
+  clear({ clients = true, cache = true } = {}) {
     this.manager.clear();
     if (clients) {
       this.clients?.forEach((client) => this.disconnect(client));
@@ -13702,8 +13740,6 @@ var Coordinator = class {
     }
     if (cache)
       this.manager.cache().clear();
-    if (catalog)
-      this.catalog.clear();
   }
   databaseConnector(db) {
     return this.manager.connector(db);
@@ -13756,7 +13792,7 @@ var Coordinator = class {
    * @param {import('./MosaicClient.js').MosaicClient} client the client to disconnect
    */
   async connect(client) {
-    const { catalog, clients, filterGroups, indexes } = this;
+    const { clients, filterGroups, indexes } = this;
     if (clients.has(client)) {
       throw new Error("Client already connected.");
     }
@@ -13764,7 +13800,7 @@ var Coordinator = class {
     client.coordinator = this;
     const fields = client.fields();
     if (fields?.length) {
-      client.fieldInfo(await catalog.queryFields(fields));
+      client.fieldInfo(await queryFieldInfo(this, fields));
     }
     const filter = client.filterBy;
     if (filter) {