@kepler.gl/duckdb 3.1.0-alpha.6

package/dist/table/duckdb-table.js

@@ -0,0 +1,443 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeplerGlDuckDbTable = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var arrow = _interopRequireWildcard(require("apache-arrow"));
+var _constants = require("@kepler.gl/constants");
+var _table = require("@kepler.gl/table");
+var _processors = require("@kepler.gl/processors");
+var _init = require("../init");
+var _dataProcessor = require("../processors/data-processor");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, e, r, o) { var p = (0, _get2["default"])((0, _getPrototypeOf2["default"])(1 & o ? t.prototype : t), e, r); return 2 & o ? function (t) { return p.apply(r, t); } : p; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// TODO format geojson, all binary geogson columns should be tranformed to wkb
+var GEOMETRY_COLUMN = 'geom';
+/**
+ * Creates an arrow table from arrow vectors and fields.
+ * @param columns An array of arrow vectors.
+ * @param fields An array of fields per arrow vector.
+ * @returns An arrow table.
+ */
+// TODO: consider using original drag&dropped arrow table, as it could contain extra metadata, not passed to the fields.
+var restoreArrowTable = function restoreArrowTable(columns, fields) {
+  var creaOpts = {};
+  fields.map(function (field, index) {
+    creaOpts[field.name] = columns[index];
+  });
+  return new arrow.Table(creaOpts);
+};
+var dropIfTableExists = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(c, tableName) {
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return c.query("DROP TABLE IF EXISTS \"".concat(tableName, "\";"));
+        case 3:
+          _context.next = 8;
+          break;
+        case 5:
+          _context.prev = 5;
+          _context.t0 = _context["catch"](0);
+          console.error('Dropping table failed', tableName, _context.t0);
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 5]]);
+  }));
+  return function dropIfTableExists(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var KeplerGlDuckDbTable = exports.KeplerGlDuckDbTable = /*#__PURE__*/function (_KeplerTable) {
+  function KeplerGlDuckDbTable(props) {
+    (0, _classCallCheck2["default"])(this, KeplerGlDuckDbTable);
+    return _callSuper(this, KeplerGlDuckDbTable, [props]);
+  }
+  (0, _inherits2["default"])(KeplerGlDuckDbTable, _KeplerTable);
+  return (0, _createClass2["default"])(KeplerGlDuckDbTable, [{
+    key: "importRowData",
+    value: function () {
+      var _importRowData = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref2) {
+        var data, db, c, fields, rows, rowsForDb, columns, createTableSql;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              data = _ref2.data, db = _ref2.db, c = _ref2.c;
+              _context2.prev = 1;
+              fields = data.fields, rows = data.rows; // DATASET_FORMATS.keplergl loads data as any[][] instead of [{}]
+              // TODO potential memory usage explosion: original data, new object and then DuckDb table
+              rowsForDb = Array.isArray(rows[0]) ? rows.map(function (row) {
+                var newRow = {};
+                row.forEach(function (value, index) {
+                  newRow[fields[index].name] = value;
+                });
+                return newRow;
+              }) : rows;
+              _context2.next = 6;
+              return db.registerFileText(this.id, JSON.stringify(rowsForDb));
+            case 6:
+              columns = fields.reduce(function (acc, field, index) {
+                // @ts-expect-error TODO extend fields to contain duckDBColumnType
+                return "".concat(acc).concat(index > 0 ? ',' : '', " '").concat(field.name, "': '").concat(field.duckDBColumnType, "'");
+              }, '');
+              createTableSql = "\n        CREATE TABLE '".concat(this.label, "' AS\n        SELECT *\n        FROM read_json('").concat(this.id, "',\n                       columns = {").concat(columns, "});\n      ");
+              _context2.next = 10;
+              return c.query(createTableSql);
+            case 10:
+              _context2.next = 15;
+              break;
+            case 12:
+              _context2.prev = 12;
+              _context2.t0 = _context2["catch"](1);
+              console.log('importRowData', _context2.t0);
+            case 15:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 12]]);
+      }));
+      function importRowData(_x3) {
+        return _importRowData.apply(this, arguments);
+      }
+      return importRowData;
+    }()
+  }, {
+    key: "importGeoJsonData",
+    value: function () {
+      var _importGeoJsonData = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref3) {
+        var data, db, c, rows, createTableSql;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              data = _ref3.data, db = _ref3.db, c = _ref3.c;
+              _context3.prev = 1;
+              rows = data.rows;
+              _context3.next = 5;
+              return db.registerFileText(this.id, JSON.stringify(rows));
+            case 5:
+              createTableSql = "\n        install spatial;\n        load spatial;\n        CREATE TABLE '".concat(this.label, "' AS \n        SELECT *\n        FROM ST_READ('").concat(this.id, "');\n      ");
+              _context3.next = 8;
+              return c.query(createTableSql);
+            case 8:
+              _context3.next = 13;
+              break;
+            case 10:
+              _context3.prev = 10;
+              _context3.t0 = _context3["catch"](1);
+              console.error('importGeoJsonData', _context3.t0);
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[1, 10]]);
+      }));
+      function importGeoJsonData(_x4) {
+        return _importGeoJsonData.apply(this, arguments);
+      }
+      return importGeoJsonData;
+    }()
+  }, {
+    key: "importArrowData",
+    value: function () {
+      var _importArrowData = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(_ref4) {
+        var data, db, c, arrowTable, setupSql;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              data = _ref4.data, db = _ref4.db, c = _ref4.c;
+              _context4.prev = 1;
+              // 1) data.rows contains an arrow table created by Add to Map data from DuckDb query.
+              // 2) arrow table is in cols & fields when a file is dragged & dropped into Add Data To Map dialog.
+              arrowTable = data.rows instanceof arrow.Table ? data.rows : restoreArrowTable(data.cols || [], data.fields);
+              setupSql = "\n        install spatial;\n        load spatial;\n      ";
+              _context4.next = 6;
+              return c.query(setupSql);
+            case 6:
+              _context4.next = 8;
+              return c.insertArrowTable(arrowTable, {
+                name: this.label
+              });
+            case 8:
+              _context4.next = 13;
+              break;
+            case 10:
+              _context4.prev = 10;
+              _context4.t0 = _context4["catch"](1);
+              // Known issues:
+              // 1) Arrow Type with extension name: geoarrow.point and format: +w:2 is not currently supported in DuckDB.
+              console.error('importArrowData', _context4.t0);
+            case 13:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[1, 10]]);
+      }));
+      function importArrowData(_x5) {
+        return _importArrowData.apply(this, arguments);
+      }
+      return importArrowData;
+    }()
+    /**
+     * Creates a table from data, returns an arrow table with the data
+     * @param data
+     * @returns {Promise<{fields: Field[], cols: any[]}>}
+     */
+  }, {
+    key: "createTableAndGetArrow",
+    value: (function () {
+      var _createTableAndGetArrow = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(data) {
+        var db, c, tableName, format, _data$rows, _data$rows2, _data$rows3, _data$cols, fields, cols, _data$fields, dummyResult, hasBinaryGeoField, arrowResult, geoField;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return (0, _init.getDuckDB)();
+            case 2:
+              db = _context5.sent;
+              _context5.next = 5;
+              return db.connect();
+            case 5:
+              c = _context5.sent;
+              tableName = this.label;
+              _context5.next = 9;
+              return dropIfTableExists(c, tableName);
+            case 9:
+              format = this.metadata.format;
+              if (!format) {
+                // format is missing when we load Kepler.gl examples
+                if (Array.isArray((_data$rows = data.rows) === null || _data$rows === void 0 ? void 0 : _data$rows[0]) || (0, _typeof2["default"])((_data$rows2 = data.rows) === null || _data$rows2 === void 0 ? void 0 : _data$rows2[0]) === 'object') {
+                  format = _constants.DATASET_FORMATS.row;
+                } else if (((_data$rows3 = data.rows) === null || _data$rows3 === void 0 ? void 0 : _data$rows3.type) === 'FeatureCollection') {
+                  format = _constants.DATASET_FORMATS.geojson;
+                } else if (((_data$cols = data.cols) === null || _data$cols === void 0 ? void 0 : _data$cols[0]) instanceof arrow.Vector) {
+                  format = _constants.DATASET_FORMATS.arrow;
+                }
+              }
+              if (!(format === _constants.DATASET_FORMATS.row)) {
+                _context5.next = 16;
+                break;
+              }
+              _context5.next = 14;
+              return this.importRowData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 14:
+              _context5.next = 27;
+              break;
+            case 16:
+              if (!(format === _constants.DATASET_FORMATS.geojson)) {
+                _context5.next = 21;
+                break;
+              }
+              _context5.next = 19;
+              return this.importGeoJsonData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 19:
+              _context5.next = 27;
+              break;
+            case 21:
+              if (!(format === _constants.DATASET_FORMATS.arrow)) {
+                _context5.next = 26;
+                break;
+              }
+              _context5.next = 24;
+              return this.importArrowData({
+                data: data,
+                db: db,
+                c: c
+              });
+            case 24:
+              _context5.next = 27;
+              break;
+            case 26:
+              console.error('Unrecognized format', format);
+            case 27:
+              fields = [];
+              cols = [];
+              _context5.prev = 29;
+              _context5.next = 32;
+              return c.query("\n        SELECT * FROM '".concat(tableName, "' LIMIT 0;\n      "));
+            case 32:
+              dummyResult = _context5.sent;
+              hasBinaryGeoField = Boolean(dummyResult.schema.fields.find(function (f) {
+                return f.name === GEOMETRY_COLUMN && arrow.DataType.isBinary(f.type);
+              })); // TODO don't do this for all columns named 'geom', check whether it's a wkb and not something else!
+              // query and transform geometry column to wkb
+              _context5.next = 36;
+              return c.query("SELECT * ".concat(hasBinaryGeoField ? "EXCLUDE ".concat(GEOMETRY_COLUMN, ", ST_AsWKB(").concat(GEOMETRY_COLUMN, ") as ").concat(GEOMETRY_COLUMN) : '', " FROM '").concat(tableName, "';"));
+            case 36:
+              arrowResult = _context5.sent;
+              geoField = arrowResult.schema.fields.find(function (f) {
+                return f.name === GEOMETRY_COLUMN && arrow.DataType.isBinary(f.type);
+              });
+              geoField === null || geoField === void 0 || geoField.metadata.set('ARROW:extension:name', 'geoarrow.wkb');
+              fields = (_data$fields = data.fields) !== null && _data$fields !== void 0 ? _data$fields : (0, _processors.arrowSchemaToFields)(arrowResult.schema);
+              cols = (0, _toConsumableArray2["default"])(Array(arrowResult.numCols).keys()).map(function (i) {
+                return arrowResult.getChildAt(i);
+              }).filter(function (col) {
+                return col;
+              });
+              _context5.next = 46;
+              break;
+            case 43:
+              _context5.prev = 43;
+              _context5.t0 = _context5["catch"](29);
+              // Known issues:
+              // 1) ST_AsWKB binder error, no type match
+              console.error('DuckDb table: binary geometry column to wkb', _context5.t0);
+            case 46:
+              _context5.next = 48;
+              return c.close();
+            case 48:
+              return _context5.abrupt("return", {
+                fields: fields,
+                cols: cols
+              });
+            case 49:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[29, 43]]);
+      }));
+      function createTableAndGetArrow(_x6) {
+        return _createTableAndGetArrow.apply(this, arguments);
+      }
+      return createTableAndGetArrow;
+    }())
+  }, {
+    key: "importData",
+    value: function () {
+      var _importData = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(_ref5) {
+        var data, _yield$this$createTab, fields, cols;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              data = _ref5.data;
+              if (!(this.type === _constants.DatasetType.VECTOR_TILE)) {
+                _context6.next = 4;
+                break;
+              }
+              _superPropGet(KeplerGlDuckDbTable, "importData", this, 3)([{
+                data: _objectSpread(_objectSpread({}, data), {}, {
+                  rows: []
+                })
+              }]);
+              return _context6.abrupt("return");
+            case 4:
+              _context6.next = 6;
+              return this.createTableAndGetArrow(data);
+            case 6:
+              _yield$this$createTab = _context6.sent;
+              fields = _yield$this$createTab.fields;
+              cols = _yield$this$createTab.cols;
+              _superPropGet(KeplerGlDuckDbTable, "importData", this, 3)([{
+                data: {
+                  fields: fields,
+                  cols: cols,
+                  rows: []
+                }
+              }]);
+            case 10:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function importData(_x7) {
+        return _importData.apply(this, arguments);
+      }
+      return importData;
+    }()
+  }, {
+    key: "update",
+    value: function () {
+      var _update = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(data) {
+        var _yield$this$createTab2, cols;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              if (!(this.type === _constants.DatasetType.VECTOR_TILE)) {
+                _context7.next = 3;
+                break;
+              }
+              _superPropGet(KeplerGlDuckDbTable, "importData", this, 3)([{
+                data: data
+              }]);
+              return _context7.abrupt("return", this);
+            case 3:
+              _context7.next = 5;
+              return this.createTableAndGetArrow(data);
+            case 5:
+              _yield$this$createTab2 = _context7.sent;
+              cols = _yield$this$createTab2.cols;
+              return _context7.abrupt("return", _superPropGet(KeplerGlDuckDbTable, "update", this, 3)([{
+                cols: cols,
+                rows: [],
+                fields: []
+              }]));
+            case 8:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function update(_x8) {
+        return _update.apply(this, arguments);
+      }
+      return update;
+    }()
+  }]);
+}(_table.KeplerTable);
+(0, _defineProperty2["default"])(KeplerGlDuckDbTable, "getFileProcessor", function (data, inputFormat) {
+  var processor;
+  var format;
+  if (inputFormat === _constants.DATASET_FORMATS.arrow || (0, _processors.isArrowData)(data)) {
+    format = _constants.DATASET_FORMATS.arrow;
+    // TODO injest arrow files from disk without loaders
+    processor = _processors.processArrowBatches;
+  } else if (inputFormat === _constants.DATASET_FORMATS.keplergl || (0, _processors.isKeplerGlMap)(data)) {
+    format = _constants.DATASET_FORMATS.keplergl;
+    processor = _dataProcessor.processKeplerglJSONforDuckDb;
+  } else if (inputFormat === _constants.DATASET_FORMATS.row || (0, _processors.isRowObject)(data)) {
+    // csv file goes here
+    format = _constants.DATASET_FORMATS.row;
+    processor = _dataProcessor.processCsvRowObject; // directly import json object into duckdb-wasm
+  } else if (inputFormat === _constants.DATASET_FORMATS.geojson || (0, _processors.isGeoJson)(data)) {
+    format = _constants.DATASET_FORMATS.geojson;
+    processor = _dataProcessor.processGeojson;
+  }
+  return {
+    processor: processor,
+    format: format
+  };
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["arrow","_interopRequireWildcard","require","_constants","_table","_processors","_init","_dataProcessor","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof3","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","Boolean","prototype","valueOf","_superPropGet","p","_get2","GEOMETRY_COLUMN","restoreArrowTable","columns","fields","creaOpts","map","field","index","name","Table","dropIfTableExists","_ref","_asyncToGenerator2","_regenerator","mark","_callee","c","tableName","wrap","_callee$","_context","prev","next","query","concat","t0","console","error","stop","_x","_x2","KeplerGlDuckDbTable","exports","_KeplerTable","props","_classCallCheck2","_inherits2","_createClass2","key","value","_importRowData","_callee2","_ref2","data","db","rows","rowsForDb","createTableSql","_callee2$","_context2","Array","isArray","row","newRow","registerFileText","id","JSON","stringify","reduce","acc","duckDBColumnType","label","log","importRowData","_x3","_importGeoJsonData","_callee3","_ref3","_callee3$","_context3","importGeoJsonData","_x4","_importArrowData","_callee4","_ref4","arrowTable","setupSql","_callee4$","_context4","cols","insertArrowTable","importArrowData","_x5","_createTableAndGetArrow","_callee5","format","_data$rows","_data$rows2","_data$rows3","_data$cols","_data$fields","dummyResult","hasBinaryGeoField","arrowResult","geoField","_callee5$","_context5","getDuckDB","sent","connect","metadata","_typeof2","DATASET_FORMATS","type","geojson","Vector","schema","find","f","DataType","isBinary","arrowSchemaToFields","_toConsumableArray2","numCols","getChildAt","col","close","abrupt","createTableAndGetArrow","_x6","_importData","_callee6","_ref5","_yield$this$createTab","_callee6$","_context6","DatasetType","VECTOR_TILE","importData","_x7","_update","_callee7","_yield$this$createTab2","_callee7$","_context7","update","_x8","KeplerTable","inputFormat","processor","isArrowData","processArrowBatches","keplergl","isKeplerGlMap","processKeplerglJSONforDuckDb","isRowObject","processCsvRowObject","isGeoJson","processGeojson"],"sources":["../../src/table/duckdb-table.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport {AsyncDuckDB, AsyncDuckDBConnection} from '@duckdb/duckdb-wasm';\n\nimport {DatasetType, DATASET_FORMATS} from '@kepler.gl/constants';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {Field, ProtoDatasetField} from '@kepler.gl/types';\nimport {\n  arrowSchemaToFields,\n  isArrowData,\n  isGeoJson,\n  isKeplerGlMap,\n  isRowObject,\n  processArrowBatches\n} from '@kepler.gl/processors';\n\nimport {getDuckDB} from '../init';\nimport {\n  processCsvRowObject,\n  processGeojson,\n  processKeplerglJSONforDuckDb,\n  ProcessorResult\n} from '../processors/data-processor';\n\n// TODO format geojson, all binary geogson columns should be tranformed to wkb\nconst GEOMETRY_COLUMN = 'geom';\n\ntype ImportDataToDuckProps = {\n  data: ProcessorResult;\n  db: AsyncDuckDB;\n  c: AsyncDuckDBConnection;\n};\n\n/**\n * Creates an arrow table from arrow vectors and fields.\n * @param columns An array of arrow vectors.\n * @param fields An array of fields per arrow vector.\n * @returns An arrow table.\n */\n// TODO: consider using original drag&dropped arrow table, as it could contain extra metadata, not passed to the fields.\nconst restoreArrowTable = (columns: arrow.Vector[], fields: ProtoDatasetField[]) => {\n  const creaOpts = {};\n  fields.map((field, index) => {\n    creaOpts[field.name] = columns[index];\n  });\n  return new arrow.Table(creaOpts);\n};\n\nconst dropIfTableExists = async (c: AsyncDuckDBConnection, tableName: string) => {\n  try {\n    await c.query(`DROP TABLE IF EXISTS \"${tableName}\";`);\n  } catch (error) {\n    console.error('Dropping table failed', tableName, error);\n  }\n};\n\nexport class KeplerGlDuckDbTable extends KeplerTable {\n  declare readonly id: string;\n  declare label: string;\n  declare type: string;\n  declare metadata: Record<string, any>;\n\n  constructor(props) {\n    super(props);\n  }\n\n  async importRowData({data, db, c}: ImportDataToDuckProps): Promise<void> {\n    try {\n      const {fields, rows} = data;\n\n      // DATASET_FORMATS.keplergl loads data as any[][] instead of [{}]\n      // TODO potential memory usage explosion: original data, new object and then DuckDb table\n      const rowsForDb = Array.isArray(rows[0])\n        ? rows.map(row => {\n            const newRow = {};\n            row.forEach((value, index) => {\n              newRow[fields[index].name] = value;\n            });\n            return newRow;\n          })\n        : rows;\n\n      await db.registerFileText(this.id, JSON.stringify(rowsForDb));\n\n      const columns = fields.reduce((acc, field, index) => {\n        // @ts-expect-error TODO extend fields to contain duckDBColumnType\n        return `${acc}${index > 0 ? ',' : ''} '${field.name}': '${field.duckDBColumnType}'`;\n      }, '');\n\n      const createTableSql = `\n        CREATE TABLE '${this.label}' AS\n        SELECT *\n        FROM read_json('${this.id}',\n                       columns = {${columns}});\n      `;\n      await c.query(createTableSql);\n    } catch (error) {\n      console.log('importRowData', error);\n    }\n  }\n\n  async importGeoJsonData({data, db, c}: ImportDataToDuckProps): Promise<void> {\n    try {\n      const {rows} = data;\n      await db.registerFileText(this.id, JSON.stringify(rows));\n\n      const createTableSql = `\n        install spatial;\n        load spatial;\n        CREATE TABLE '${this.label}' AS \n        SELECT *\n        FROM ST_READ('${this.id}');\n      `;\n      await c.query(createTableSql);\n    } catch (error) {\n      console.error('importGeoJsonData', error);\n    }\n  }\n\n  async importArrowData({data, db, c}: ImportDataToDuckProps): Promise<void> {\n    try {\n      // 1) data.rows contains an arrow table created by Add to Map data from DuckDb query.\n      // 2) arrow table is in cols & fields when a file is dragged & dropped into Add Data To Map dialog.\n      const arrowTable =\n        data.rows instanceof arrow.Table\n          ? data.rows\n          : restoreArrowTable(data.cols || [], data.fields);\n\n      const setupSql = `\n        install spatial;\n        load spatial;\n      `;\n      await c.query(setupSql);\n      await c.insertArrowTable(arrowTable, {name: this.label});\n    } catch (error) {\n      // Known issues:\n      // 1) Arrow Type with extension name: geoarrow.point and format: +w:2 is not currently supported in DuckDB.\n      console.error('importArrowData', error);\n    }\n  }\n\n  /**\n   * Creates a table from data, returns an arrow table with the data\n   * @param data\n   * @returns {Promise<{fields: Field[], cols: any[]}>}\n   */\n  protected async createTableAndGetArrow(data): Promise<{fields: any[]; cols: arrow.Vector[]}> {\n    const db = await getDuckDB();\n    const c = await db.connect();\n\n    const tableName = this.label;\n    await dropIfTableExists(c, tableName);\n\n    let format = this.metadata.format;\n    if (!format) {\n      // format is missing when we load Kepler.gl examples\n      if (Array.isArray(data.rows?.[0]) || typeof data.rows?.[0] === 'object') {\n        format = DATASET_FORMATS.row;\n      } else if (data.rows?.type === 'FeatureCollection') {\n        format = DATASET_FORMATS.geojson;\n      } else if (data.cols?.[0] instanceof arrow.Vector) {\n        format = DATASET_FORMATS.arrow;\n      }\n    }\n\n    if (format === DATASET_FORMATS.row) {\n      await this.importRowData({data, db, c});\n    } else if (format === DATASET_FORMATS.geojson) {\n      await this.importGeoJsonData({data, db, c});\n    } else if (format === DATASET_FORMATS.arrow) {\n      await this.importArrowData({data, db, c});\n    } else {\n      console.error('Unrecognized format', format);\n    }\n\n    let fields: Field[] = [];\n    let cols: arrow.Vector[] = [];\n\n    try {\n      // We need to transform the binary geometry column to proper wkb.\n      // First check whether such a column exists, then query with ST_AsWKB.\n      const dummyResult = await c.query(`\n        SELECT * FROM '${tableName}' LIMIT 0;\n      `);\n      const hasBinaryGeoField = Boolean(\n        dummyResult.schema.fields.find(\n          f => f.name === GEOMETRY_COLUMN && arrow.DataType.isBinary(f.type)\n        )\n      );\n\n      // TODO don't do this for all columns named 'geom', check whether it's a wkb and not something else!\n      // query and transform geometry column to wkb\n      const arrowResult = await c.query(\n        `SELECT * ${\n          hasBinaryGeoField\n            ? `EXCLUDE ${GEOMETRY_COLUMN}, ST_AsWKB(${GEOMETRY_COLUMN}) as ${GEOMETRY_COLUMN}`\n            : ''\n        } FROM '${tableName}';`\n      );\n      const geoField = arrowResult.schema.fields.find(\n        f => f.name === GEOMETRY_COLUMN && arrow.DataType.isBinary(f.type)\n      );\n      geoField?.metadata.set('ARROW:extension:name', 'geoarrow.wkb');\n\n      fields = data.fields ?? arrowSchemaToFields(arrowResult.schema);\n      cols = [...Array(arrowResult.numCols).keys()]\n        .map(i => arrowResult.getChildAt(i))\n        .filter(col => col) as arrow.Vector[];\n    } catch (error) {\n      // Known issues:\n      // 1) ST_AsWKB binder error, no type match\n      console.error('DuckDb table: binary geometry column to wkb', error);\n    }\n\n    await c.close();\n\n    return {fields, cols};\n  }\n\n  async importData({data}: {data: ProcessorResult}): Promise<void> {\n    // VectorTile is a special case, ignore for now\n    if (this.type === DatasetType.VECTOR_TILE) {\n      super.importData({data: {...data, rows: []}});\n      return;\n    }\n\n    const {fields, cols} = await this.createTableAndGetArrow(data);\n\n    super.importData({data: {fields, cols, rows: []}});\n  }\n\n  async update(data) {\n    // VectorTile is a special case, ignore for now\n    if (this.type === DatasetType.VECTOR_TILE) {\n      super.importData({data});\n      return this;\n    }\n\n    const {cols} = await this.createTableAndGetArrow(data);\n\n    return super.update({cols, rows: [], fields: []});\n  }\n\n  static getFileProcessor = function (data: any, inputFormat?: string) {\n    let processor;\n    let format;\n    if (inputFormat === DATASET_FORMATS.arrow || isArrowData(data)) {\n      format = DATASET_FORMATS.arrow;\n      // TODO injest arrow files from disk without loaders\n      processor = processArrowBatches;\n    } else if (inputFormat === DATASET_FORMATS.keplergl || isKeplerGlMap(data)) {\n      format = DATASET_FORMATS.keplergl;\n      processor = processKeplerglJSONforDuckDb;\n    } else if (inputFormat === DATASET_FORMATS.row || isRowObject(data)) {\n      // csv file goes here\n      format = DATASET_FORMATS.row;\n      processor = processCsvRowObject; // directly import json object into duckdb-wasm\n    } else if (inputFormat === DATASET_FORMATS.geojson || isGeoJson(data)) {\n      format = DATASET_FORMATS.geojson;\n      processor = processGeojson;\n    }\n    return {processor, format};\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/perf.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Print the elapsed time to console.debug.
+ */
+export declare const logElapsedTime: (label: string, start: number, end?: number | undefined) => void;

package/dist/utils/perf.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logElapsedTime = void 0;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// git@github.com:holdenmatt/duckdb-wasm-kit.git
+var FgRed = '\x1b[31m';
+var ResetColors = '\x1b[0m';
+
+/**
+ * Format a time interval between start/end timestamps.
+ *
+ * If no end time is given, use the current time.
+ */
+var formatElapsedTime = function formatElapsedTime(label, start) {
+  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  var endTime = end !== null && end !== void 0 ? end : performance.now();
+  var elapsed = endTime - start;
+  var timeString;
+  switch (true) {
+    case elapsed >= 1000:
+      timeString = "".concat((elapsed / 1000).toFixed(1), "s");
+      break;
+    case elapsed >= 1:
+      timeString = "".concat(elapsed.toFixed(0), "ms");
+      break;
+    default:
+      timeString = "".concat(elapsed.toFixed(3), "ms");
+      break;
+  }
+  var message = "".concat(FgRed, "[").concat(timeString, "] ").concat(ResetColors).concat(label);
+  return message;
+};
+
+/**
+ * Print the elapsed time to console.debug.
+ */
+var logElapsedTime = exports.logElapsedTime = function logElapsedTime(label, start) {
+  var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  console.debug(formatElapsedTime(label, start, end));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJGZ1JlZCIsIlJlc2V0Q29sb3JzIiwiZm9ybWF0RWxhcHNlZFRpbWUiLCJsYWJlbCIsInN0YXJ0IiwiZW5kIiwiYXJndW1lbnRzIiwibGVuZ3RoIiwidW5kZWZpbmVkIiwiZW5kVGltZSIsInBlcmZvcm1hbmNlIiwibm93IiwiZWxhcHNlZCIsInRpbWVTdHJpbmciLCJjb25jYXQiLCJ0b0ZpeGVkIiwibWVzc2FnZSIsImxvZ0VsYXBzZWRUaW1lIiwiZXhwb3J0cyIsImNvbnNvbGUiLCJkZWJ1ZyJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9wZXJmLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbi8vIGdpdEBnaXRodWIuY29tOmhvbGRlbm1hdHQvZHVja2RiLXdhc20ta2l0LmdpdFxuY29uc3QgRmdSZWQgPSAnXFx4MWJbMzFtJztcbmNvbnN0IFJlc2V0Q29sb3JzID0gJ1xceDFiWzBtJztcblxuLyoqXG4gKiBGb3JtYXQgYSB0aW1lIGludGVydmFsIGJldHdlZW4gc3RhcnQvZW5kIHRpbWVzdGFtcHMuXG4gKlxuICogSWYgbm8gZW5kIHRpbWUgaXMgZ2l2ZW4sIHVzZSB0aGUgY3VycmVudCB0aW1lLlxuICovXG5jb25zdCBmb3JtYXRFbGFwc2VkVGltZSA9IChcbiAgbGFiZWw6IHN0cmluZyxcbiAgc3RhcnQ6IG51bWJlcixcbiAgZW5kOiBudW1iZXIgfCB1bmRlZmluZWQgPSB1bmRlZmluZWRcbik6IHN0cmluZyA9PiB7XG4gIGNvbnN0IGVuZFRpbWUgPSBlbmQgPz8gcGVyZm9ybWFuY2Uubm93KCk7XG4gIGNvbnN0IGVsYXBzZWQgPSBlbmRUaW1lIC0gc3RhcnQ7XG5cbiAgbGV0IHRpbWVTdHJpbmc6IHN0cmluZztcbiAgc3dpdGNoICh0cnVlKSB7XG4gICAgY2FzZSBlbGFwc2VkID49IDEwMDA6XG4gICAgICB0aW1lU3RyaW5nID0gYCR7KGVsYXBzZWQgLyAxMDAwKS50b0ZpeGVkKDEpfXNgO1xuICAgICAgYnJlYWs7XG4gICAgY2FzZSBlbGFwc2VkID49IDE6XG4gICAgICB0aW1lU3RyaW5nID0gYCR7ZWxhcHNlZC50b0ZpeGVkKDApfW1zYDtcbiAgICAgIGJyZWFrO1xuICAgIGRlZmF1bHQ6XG4gICAgICB0aW1lU3RyaW5nID0gYCR7ZWxhcHNlZC50b0ZpeGVkKDMpfW1zYDtcbiAgICAgIGJyZWFrO1xuICB9XG5cbiAgY29uc3QgbWVzc2FnZSA9IGAke0ZnUmVkfVske3RpbWVTdHJpbmd9XSAke1Jlc2V0Q29sb3JzfSR7bGFiZWx9YDtcbiAgcmV0dXJuIG1lc3NhZ2U7XG59O1xuXG4vKipcbiAqIFByaW50IHRoZSBlbGFwc2VkIHRpbWUgdG8gY29uc29sZS5kZWJ1Zy5cbiAqL1xuZXhwb3J0IGNvbnN0IGxvZ0VsYXBzZWRUaW1lID0gKFxuICBsYWJlbDogc3RyaW5nLFxuICBzdGFydDogbnVtYmVyLFxuICBlbmQ6IG51bWJlciB8IHVuZGVmaW5lZCA9IHVuZGVmaW5lZFxuKSA9PiB7XG4gIGNvbnNvbGUuZGVidWcoZm9ybWF0RWxhcHNlZFRpbWUobGFiZWwsIHN0YXJ0LCBlbmQpKTtcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7O0FBRUE7QUFDQSxJQUFNQSxLQUFLLEdBQUcsVUFBVTtBQUN4QixJQUFNQyxXQUFXLEdBQUcsU0FBUzs7QUFFN0I7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLElBQU1DLGlCQUFpQixHQUFHLFNBQXBCQSxpQkFBaUJBLENBQ3JCQyxLQUFhLEVBQ2JDLEtBQWEsRUFFRjtFQUFBLElBRFhDLEdBQXVCLEdBQUFDLFNBQUEsQ0FBQUMsTUFBQSxRQUFBRCxTQUFBLFFBQUFFLFNBQUEsR0FBQUYsU0FBQSxNQUFHRSxTQUFTO0VBRW5DLElBQU1DLE9BQU8sR0FBR0osR0FBRyxhQUFIQSxHQUFHLGNBQUhBLEdBQUcsR0FBSUssV0FBVyxDQUFDQyxHQUFHLENBQUMsQ0FBQztFQUN4QyxJQUFNQyxPQUFPLEdBQUdILE9BQU8sR0FBR0wsS0FBSztFQUUvQixJQUFJUyxVQUFrQjtFQUN0QixRQUFRLElBQUk7SUFDVixLQUFLRCxPQUFPLElBQUksSUFBSTtNQUNsQkMsVUFBVSxNQUFBQyxNQUFBLENBQU0sQ0FBQ0YsT0FBTyxHQUFHLElBQUksRUFBRUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFHO01BQzlDO0lBQ0YsS0FBS0gsT0FBTyxJQUFJLENBQUM7TUFDZkMsVUFBVSxNQUFBQyxNQUFBLENBQU1GLE9BQU8sQ0FBQ0csT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFJO01BQ3RDO0lBQ0Y7TUFDRUYsVUFBVSxNQUFBQyxNQUFBLENBQU1GLE9BQU8sQ0FBQ0csT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFJO01BQ3RDO0VBQ0o7RUFFQSxJQUFNQyxPQUFPLE1BQUFGLE1BQUEsQ0FBTWQsS0FBSyxPQUFBYyxNQUFBLENBQUlELFVBQVUsUUFBQUMsTUFBQSxDQUFLYixXQUFXLEVBQUFhLE1BQUEsQ0FBR1gsS0FBSyxDQUFFO0VBQ2hFLE9BQU9hLE9BQU87QUFDaEIsQ0FBQzs7QUFFRDtBQUNBO0FBQ0E7QUFDTyxJQUFNQyxjQUFjLEdBQUFDLE9BQUEsQ0FBQUQsY0FBQSxHQUFHLFNBQWpCQSxjQUFjQSxDQUN6QmQsS0FBYSxFQUNiQyxLQUFhLEVBRVY7RUFBQSxJQURIQyxHQUF1QixHQUFBQyxTQUFBLENBQUFDLE1BQUEsUUFBQUQsU0FBQSxRQUFBRSxTQUFBLEdBQUFGLFNBQUEsTUFBR0UsU0FBUztFQUVuQ1csT0FBTyxDQUFDQyxLQUFLLENBQUNsQixpQkFBaUIsQ0FBQ0MsS0FBSyxFQUFFQyxLQUFLLEVBQUVDLEdBQUcsQ0FBQyxDQUFDO0FBQ3JELENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@kepler.gl/duckdb",
+  "author": "Shan He <heshan0131@gmail.com>",
+  "version": "3.1.0-alpha.6",
+  "description": "DuckDB plugin for Kepler.gl",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "duckdb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/keplergl/kepler.gl.git"
+  },
+  "scripts": {
+    "build": "rm -fr dist && babel src --out-dir dist --source-maps inline --extensions '.ts,.tsx,.js,.jsx' --ignore '**/*.d.ts'",
+    "build:umd": "NODE_OPTIONS=--openssl-legacy-provider webpack --config ./webpack/umd.js --progress --env.prod",
+    "build:types": "tsc --project ./tsconfig.production.json",
+    "prepublishOnly": "babel-node ../../scripts/license-header/bin --license ../../FILE-HEADER && yarn build && yarn build:types",
+    "stab": "mkdir -p dist && touch dist/index.js"
+  },
+  "files": [
+    "dist",
+    "umd"
+  ],
+  "dependencies": {
+    "@duckdb/duckdb-wasm": "^1.28.0",
+    "@kepler.gl/common-utils": "3.1.0-alpha.6",
+    "@kepler.gl/constants": "3.1.0-alpha.6",
+    "@kepler.gl/processors": "3.1.0-alpha.6",
+    "@kepler.gl/table": "3.1.0-alpha.6",
+    "@kepler.gl/types": "3.1.0-alpha.6",
+    "@monaco-editor/react": "^4.6.0",
+    "@radix-ui/react-collapsible": "^1.1.0",
+    "apache-arrow": ">=15.0.0",
+    "monaco-editor": "^0.52.0",
+    "react-resizable-panels": "^2.1.7"
+  },
+  "nyc": {
+    "sourceMap": false,
+    "instrument": false
+  },
+  "maintainers": [
+    "Shan He <heshan0131@gmail.com>",
+    "Igor Dykhta <dikhta.igor@gmail.com>",
+    "Ilya Boyandin <ilya@boyandin.me>"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "volta": {
+    "node": "18.18.2",
+    "yarn": "4.4.0"
+  },
+  "packageManager": "yarn@4.4.0"
+}